{4:}{9:}{$C-,A+,D-}{[$C+,D+]}{:9}PROGRAM MF;LABEL{6:}1,9998,9999;{:6}
CONST{11:}MEMMAX=30000;BUFSIZE=500;ERRORLINE=72;HALFERRORLIN=42;
MAXPRINTLINE=79;SCREENWIDTH=768;SCREENDEPTH=1024;STACKSIZE=30;
MAXINOPEN=6;PARAMSIZE=30;MAXSTRINGS=1500;STRINGVACANC=8000;
POOLSIZE=32000;SAVESIZE=200;MOVESIZE=5000;GFBUFSIZE=800;FILENAMESIZE=40;
POOLNAME='TeXformats:MF.POOL                      ';PATHSIZE=100;
BISTACKSIZE=154;{:11}TYPE{18:}ASCIICODE=0..127;{:18}{25:}
EIGHTBITS=0..255;ALPHAFILE=PACKED FILE OF CHAR;
BYTEFILE=PACKED FILE OF EIGHTBITS;{:25}{38:}POOLPOINTER=0..POOLSIZE;
STRNUMBER=0..MAXSTRINGS;{:38}{97:}SCALED=INTEGER;
NONNEGATIVEI=0..2147483647;SMALLNUMBER=0..63;{:97}{101:}
FRACTION=INTEGER;{:101}{102:}ANGLE=INTEGER;{:102}{149:}
QUARTERWORD=0..255;HALFWORD=0..65535;TWOCHOICES=1..2;THREECHOICES=1..3;
TWOHALVES=PACKED RECORD RH:HALFWORD;CASE TWOCHOICES OF 1:(LH:HALFWORD);
2:(B0:QUARTERWORD;B1:QUARTERWORD);END;
FOURQUARTERS=PACKED RECORD B0:QUARTERWORD;B1:QUARTERWORD;B2:QUARTERWORD;
B3:QUARTERWORD;END;
MEMORYWORD=RECORD CASE THREECHOICES OF 1:(INT:INTEGER);2:(HH:TWOHALVES);
3:(QQQQ:FOURQUARTERS);END;WORDFILE=FILE OF MEMORYWORD;{:149}{473:}
SCREENROW=0..SCREENDEPTH;SCREENCOL=0..SCREENWIDTH;
TRANSSPEC=ARRAY[SCREENROW]OF SCREENCOL;PIXELCOLOR=0..1;{:473}{479:}
WINDOWNUMBER=0..15;{:479}{497:}
INSTATERECOR=RECORD INDEXFIELD:QUARTERWORD;
STARTFIELD,LOCFIELD,LIMITFIELD,NAMEFIELD:HALFWORD;END;{:497}{647:}
GFINDEX=0..GFBUFSIZE;{:647}VAR{13:}BAD:INTEGER;{:13}{20:}
XORD:ARRAY[CHAR]OF ASCIICODE;XCHR:ARRAY[ASCIICODE]OF CHAR;{:20}{26:}
NAMEOFFILE:PACKED ARRAY[1..FILENAMESIZE]OF CHAR;
NAMELENGTH:0..FILENAMESIZE;{:26}{30:}
BUFFER:ARRAY[0..BUFSIZE]OF ASCIICODE;FIRST:0..BUFSIZE;LAST:0..BUFSIZE;
MAXBUFSTACK:0..BUFSIZE;{:30}{32:}TERMIN:ALPHAFILE;TERMOUT:ALPHAFILE;
{:32}{39:}STRPOOL:PACKED ARRAY[POOLPOINTER]OF ASCIICODE;
STRSTART:ARRAY[STRNUMBER]OF POOLPOINTER;POOLPTR:POOLPOINTER;
STRPTR:STRNUMBER;INITPOOLPTR:POOLPOINTER;INITSTRPTR:STRNUMBER;{:39}{50:}
POOLFILE:ALPHAFILE;{:50}{54:}LOGFILE:ALPHAFILE;SELECTOR:0..5;
DIG:ARRAY[0..22]OF 0..15;TALLY:INTEGER;TERMOFFSET:0..MAXPRINTLINE;
FILEOFFSET:0..MAXPRINTLINE;TRICKBUF:ARRAY[0..ERRORLINE]OF ASCIICODE;
TRICKCOUNT:INTEGER;FIRSTCOUNT:INTEGER;{:54}{67:}INTERACTION:0..3;{:67}
{70:}DELETIONSALL:BOOLEAN;HISTORY:0..3;ERRORCOUNT:-1..100;{:70}{73:}
HELPLINE:ARRAY[0..5]OF STRNUMBER;HELPPTR:0..6;USEERRHELP:BOOLEAN;{:73}
{89:}INTERRUPT:INTEGER;OKTOINTERRUP:BOOLEAN;{:89}{94:}
ARITHERROR:BOOLEAN;{:94}{122:}TWOTOTHE:ARRAY[0..30]OF INTEGER;
SPECLOG:ARRAY[1..28]OF INTEGER;{:122}{130:}
SPECATAN:ARRAY[1..26]OF ANGLE;{:130}{137:}NSIN,NCOS:FRACTION;{:137}
{141:}RANDOMS:ARRAY[0..54]OF FRACTION;JRANDOM:0..54;{:141}{151:}
TEMPPTR:HALFWORD;{:151}{152:}MEM:ARRAY[0..MEMMAX]OF MEMORYWORD;{:152}
{153:}VARUSED,DYNUSED:INTEGER;MAXVARUSED:INTEGER;{:153}{154:}
AVAIL:HALFWORD;MEMEND:HALFWORD;{:154}{159:}ROVER:HALFWORD;{:159}{172:}
{FREE:PACKED ARRAY[0..MEMMAX]OF BOOLEAN;
WASFREE:PACKED ARRAY[0..MEMMAX]OF BOOLEAN;WASMEMEND:HALFWORD;
PANICKING:BOOLEAN;}{:172}{183:}INTERNAL:ARRAY[0..26]OF INTEGER;{:183}
{186:}OLDSETTING:0..5;{:186}{188:}
CHARCLASS:ARRAY[ASCIICODE]OF ASCIICODE;{:188}{190:}
HASH:ARRAY[1..2100]OF TWOHALVES;EQTB:ARRAY[1..2100]OF TWOHALVES;
HASHUSED:HALFWORD;STCOUNT:INTEGER;{:190}{233:}SAVEPTR:HALFWORD;{:233}
{243:}FIXNEEDED:BOOLEAN;DEPTAIL:HALFWORD;{:243}{285:}
DELTAX,DELTAY,DELTA:ARRAY[0..PATHSIZE]OF SCALED;
PSI:ARRAY[1..PATHSIZE]OF ANGLE;{:285}{289:}
THETA:ARRAY[0..PATHSIZE]OF ANGLE;UU:ARRAY[0..PATHSIZE]OF FRACTION;
VV:ARRAY[0..PATHSIZE]OF ANGLE;WW:ARRAY[0..PATHSIZE]OF FRACTION;{:289}
{304:}ST,CT,SF,CF:FRACTION;{:304}{312:}
MOVE:ARRAY[-1..MOVESIZE]OF INTEGER;MOVEPTR:0..MOVESIZE;{:312}{314:}
BISECTSTACK:ARRAY[0..BISTACKSIZE]OF INTEGER;BISECTPTR:0..BISTACKSIZE;
{:314}{330:}CUREDGES:HALFWORD;CURWT:INTEGER;{:330}{357:}
CURX,CURY:SCALED;{:357}{365:}WINDINGNUMBE:INTEGER;{:365}{386:}
OCTANTNUMBER:ARRAY[1..8]OF 1..8;OCTANTCODE:ARRAY[1..8]OF 1..8;{:386}
{402:}CURM,CURN,CURD:INTEGER;{:402}{443:}
ENVMOVE:ARRAY[0..MOVESIZE]OF INTEGER;{:443}{474:}
{SCREENPIXEL:ARRAY[SCREENROW,SCREENCOL]OF PIXELCOLOR;}{:474}{477:}
SCREENSTARTE:BOOLEAN;SCREENOK:BOOLEAN;{:477}{480:}
WINDOWOPEN:ARRAY[WINDOWNUMBER]OF BOOLEAN;
LEFTCOL:ARRAY[WINDOWNUMBER]OF SCREENCOL;
RIGHTCOL:ARRAY[WINDOWNUMBER]OF SCREENCOL;
TOPROW:ARRAY[WINDOWNUMBER]OF SCREENROW;
BOTROW:ARRAY[WINDOWNUMBER]OF SCREENROW;
MWINDOW:ARRAY[WINDOWNUMBER]OF INTEGER;
NWINDOW:ARRAY[WINDOWNUMBER]OF INTEGER;
WINDOWTIME:ARRAY[WINDOWNUMBER]OF INTEGER;{:480}{487:}
ROWTRANSITIO:TRANSSPEC;{:487}{494:}CURCMD:EIGHTBITS;CURMOD:HALFWORD;
CURSYM:HALFWORD;{:494}{498:}
INPUTSTACK:ARRAY[0..STACKSIZE]OF INSTATERECOR;INPUTPTR:0..STACKSIZE;
MAXINSTACK:0..STACKSIZE;CURINPUT:INSTATERECOR;{:498}{501:}
INOPEN:0..MAXINOPEN;INPUTFILE:ARRAY[1..MAXINOPEN]OF ALPHAFILE;
LINE:INTEGER;LINESTACK:ARRAY[0..MAXINOPEN]OF INTEGER;{:501}{503:}
PARAMSTACK:ARRAY[0..PARAMSIZE]OF HALFWORD;PARAMPTR:0..PARAMSIZE;
MAXPARAMSTAC:INTEGER;{:503}{504:}BASEPTR:0..STACKSIZE;{:504}{545:}
FORCEEOF:BOOLEAN;{:545}{586:}CONDPTR:HALFWORD;IFLIMIT:NORMAL..ORCODE;
CURIF:SMALLNUMBER;IFLINE:INTEGER;{:586}{590:}SKIPLINE:INTEGER;{:590}
{602:}CURNAME:STRNUMBER;CURAREA:STRNUMBER;CUREXT:STRNUMBER;{:602}{603:}
AREADELIMITE:POOLPOINTER;EXTDELIMITER:POOLPOINTER;{:603}{610:}
MFBASEDEFAUL:PACKED ARRAY[1..21]OF CHAR;{:610}{617:}JOBNAME:STRNUMBER;
{:617}{622:}GFFILE:BYTEFILE;OUTPUTFILENA:STRNUMBER;LOGNAME:STRNUMBER;
{:622}{629:}TFMFILE:BYTEFILE;{:629}{645:}
GFMINX,GFMAXX,GFMINY,GFMAXY:INTEGER;GFPREVPTR:INTEGER;
TOTALCHARS:INTEGER;CHARPTR:ARRAY[EIGHTBITS]OF INTEGER;{:645}{648:}
GFBUF:ARRAY[GFINDEX]OF EIGHTBITS;HALFBUF:GFINDEX;GFLIMIT:GFINDEX;
GFPTR:GFINDEX;GFOFFSET:INTEGER;{:648}{666:}CURTYPE:SMALLNUMBER;
CUREXP:INTEGER;{:666}{681:}BEGINNING:BOOLEAN;{:681}{787:}
BASEIDENT:STRNUMBER;{:787}{793:}BASEFILE:WORDFILE;{:793}{810:}
READYALREADY:INTEGER;{:810}PROCEDURE INITIALIZE;VAR{19:}I:0..127;{:19}
{123:}K:SMALLNUMBER;{:123}{169:}K:INTEGER;{:169}BEGIN{8:}{21:}
XCHR[32]:=' ';XCHR[33]:='!';XCHR[34]:='"';XCHR[35]:='#';XCHR[36]:='$';
XCHR[37]:='%';XCHR[38]:='&';XCHR[39]:='''';XCHR[40]:='(';XCHR[41]:=')';
XCHR[42]:='*';XCHR[43]:='+';XCHR[44]:=',';XCHR[45]:='-';XCHR[46]:='.';
XCHR[47]:='/';XCHR[48]:='0';XCHR[49]:='1';XCHR[50]:='2';XCHR[51]:='3';
XCHR[52]:='4';XCHR[53]:='5';XCHR[54]:='6';XCHR[55]:='7';XCHR[56]:='8';
XCHR[57]:='9';XCHR[58]:=':';XCHR[59]:=';';XCHR[60]:='<';XCHR[61]:='=';
XCHR[62]:='>';XCHR[63]:='?';XCHR[64]:='@';XCHR[65]:='A';XCHR[66]:='B';
XCHR[67]:='C';XCHR[68]:='D';XCHR[69]:='E';XCHR[70]:='F';XCHR[71]:='G';
XCHR[72]:='H';XCHR[73]:='I';XCHR[74]:='J';XCHR[75]:='K';XCHR[76]:='L';
XCHR[77]:='M';XCHR[78]:='N';XCHR[79]:='O';XCHR[80]:='P';XCHR[81]:='Q';
XCHR[82]:='R';XCHR[83]:='S';XCHR[84]:='T';XCHR[85]:='U';XCHR[86]:='V';
XCHR[87]:='W';XCHR[88]:='X';XCHR[89]:='Y';XCHR[90]:='Z';XCHR[91]:='[';
XCHR[92]:='\';XCHR[93]:=']';XCHR[94]:='↑';XCHR[95]:='_';XCHR[96]:='`';
XCHR[97]:='a';XCHR[98]:='b';XCHR[99]:='c';XCHR[100]:='d';XCHR[101]:='e';
XCHR[102]:='f';XCHR[103]:='g';XCHR[104]:='h';XCHR[105]:='i';
XCHR[106]:='j';XCHR[107]:='k';XCHR[108]:='l';XCHR[109]:='m';
XCHR[110]:='n';XCHR[111]:='o';XCHR[112]:='p';XCHR[113]:='q';
XCHR[114]:='r';XCHR[115]:='s';XCHR[116]:='t';XCHR[117]:='u';
XCHR[118]:='v';XCHR[119]:='w';XCHR[120]:='x';XCHR[121]:='y';
XCHR[122]:='z';XCHR[123]:='{';XCHR[124]:='|';XCHR[125]:='}';
XCHR[126]:='~';XCHR[0]:=' ';XCHR[127]:=' ';{:21}{23:}
FOR I:=1 TO 31 DO XCHR[I]:=' ';{:23}{24:}
FOR I:=0 TO 127 DO XORD[CHR(I)]:=127;
FOR I:=1 TO 126 DO XORD[XCHR[I]]:=I;{:24}{68:}INTERACTION:=3;{:68}{71:}
DELETIONSALL:=TRUE;ERRORCOUNT:=0;{:71}{74:}HELPPTR:=0;USEERRHELP:=FALSE;
{:74}{90:}INTERRUPT:=0;OKTOINTERRUP:=TRUE;{:90}{95:}ARITHERROR:=FALSE;
{:95}{124:}TWOTOTHE[0]:=1;
FOR K:=1 TO 30 DO TWOTOTHE[K]:=2*TWOTOTHE[K-1];SPECLOG[1]:=93032640;
SPECLOG[2]:=38612034;SPECLOG[3]:=17922280;SPECLOG[4]:=8662214;
SPECLOG[5]:=4261238;SPECLOG[6]:=2113709;SPECLOG[7]:=1052693;
SPECLOG[8]:=525315;SPECLOG[9]:=262400;SPECLOG[10]:=131136;
SPECLOG[11]:=65552;SPECLOG[12]:=32772;SPECLOG[13]:=16385;
FOR K:=14 TO 27 DO SPECLOG[K]:=TWOTOTHE[27-K];SPECLOG[28]:=1;{:124}
{131:}SPECATAN[1]:=27855475;SPECATAN[2]:=14718068;SPECATAN[3]:=7471121;
SPECATAN[4]:=3750058;SPECATAN[5]:=1876857;SPECATAN[6]:=938658;
SPECATAN[7]:=469357;SPECATAN[8]:=234682;SPECATAN[9]:=117342;
SPECATAN[10]:=58671;SPECATAN[11]:=29335;SPECATAN[12]:=14668;
SPECATAN[13]:=7334;SPECATAN[14]:=3667;SPECATAN[15]:=1833;
SPECATAN[16]:=917;SPECATAN[17]:=458;SPECATAN[18]:=229;SPECATAN[19]:=115;
SPECATAN[20]:=57;SPECATAN[21]:=29;SPECATAN[22]:=14;SPECATAN[23]:=7;
SPECATAN[24]:=4;SPECATAN[25]:=2;SPECATAN[26]:=1;{:131}{173:}
{WASMEMEND:=0;PANICKING:=FALSE;}{:173}{189:}
FOR K:=48 TO 57 DO CHARCLASS[K]:=0;CHARCLASS[46]:=1;
FOR K:=0 TO 32 DO CHARCLASS[K]:=2;CHARCLASS[127]:=2;CHARCLASS[37]:=3;
CHARCLASS[34]:=4;CHARCLASS[44]:=5;CHARCLASS[59]:=6;CHARCLASS[40]:=7;
CHARCLASS[41]:=8;FOR K:=65 TO 90 DO CHARCLASS[K]:=9;
FOR K:=97 TO 122 DO CHARCLASS[K]:=9;CHARCLASS[95]:=9;CHARCLASS[60]:=10;
CHARCLASS[61]:=10;CHARCLASS[62]:=10;CHARCLASS[58]:=10;
CHARCLASS[124]:=10;CHARCLASS[96]:=11;CHARCLASS[39]:=11;
CHARCLASS[43]:=12;CHARCLASS[45]:=12;CHARCLASS[47]:=13;CHARCLASS[42]:=13;
CHARCLASS[92]:=13;CHARCLASS[33]:=14;CHARCLASS[63]:=14;CHARCLASS[35]:=15;
CHARCLASS[38]:=15;CHARCLASS[64]:=15;CHARCLASS[36]:=15;CHARCLASS[94]:=16;
CHARCLASS[126]:=16;CHARCLASS[91]:=17;CHARCLASS[93]:=18;
CHARCLASS[123]:=19;CHARCLASS[125]:=19;{:189}{191:}HASH[1].LH:=0;
HASH[1].RH:=0;EQTB[1].LH:=18;EQTB[1].RH:=0;
FOR K:=2 TO 2100 DO BEGIN HASH[K]:=HASH[1];EQTB[K]:=EQTB[1];END;{:191}
{234:}SAVEPTR:=0;{:234}{244:}FIXNEEDED:=FALSE;{:244}{313:}MOVE[-1]:=-1;
{:313}{387:}OCTANTCODE[1]:=1;OCTANTCODE[2]:=5;OCTANTCODE[3]:=6;
OCTANTCODE[4]:=2;OCTANTCODE[5]:=4;OCTANTCODE[6]:=8;OCTANTCODE[7]:=7;
OCTANTCODE[8]:=3;FOR K:=1 TO 8 DO OCTANTNUMBER[OCTANTCODE[K]]:=K;{:387}
{413:}MEM[3].HH.LH:=1;MEM[3].HH.RH:=0;MEM[4].HH.LH:=1;MEM[4].HH.RH:=0;
FOR K:=5 TO 11 DO MEM[K]:=MEM[3];MEM[0].HH.RH:=0;MEM[0].HH.LH:=0;
MEM[1].INT:=0;MEM[2].INT:=0;{:413}{478:}SCREENSTARTE:=FALSE;
SCREENOK:=FALSE;{:478}{587:}CONDPTR:=0;IFLIMIT:=NORMAL;CURIF:=0;
IFLINE:=0;{:587}{611:}MFBASEDEFAUL:='TeXformats:PLAIN.base';{:611}{646:}
GFPREVPTR:=0;TOTALCHARS:=0;{:646}{649:}HALFBUF:=GFBUFSIZE DIV 2;
GFLIMIT:=GFBUFSIZE;GFPTR:=0;GFOFFSET:=0;{:649}{667:}CURTYPE:=1;
CUREXP:=0;{:667}{682:}BEGINNING:=FALSE;{:682}{788:}BASEIDENT:=0;{:788}
{170:}ROVER:=20;MEM[ROVER].HH.RH:=65535;MEM[ROVER].HH.LH:=13000-ROVER;
MEM[ROVER+1].HH.LH:=ROVER;MEM[ROVER+1].HH.RH:=ROVER;MEM[13000].HH.RH:=0;
MEM[13000].HH.LH:=0;FOR K:=13001 TO 13003 DO MEM[K]:=MEM[13000];
AVAIL:=0;MEMEND:=13003;VARUSED:=20;DYNUSED:=4;MAXVARUSED:=VARUSED;{:170}
{193:}HASHUSED:=2091;STCOUNT:=0;{:193}{217:}MEM[19].HH.LH:=2101;
MEM[19].HH.RH:=0;{:217}{239:}MEM[13].HH.RH:=13;MEM[#+1].HH.RH(13):=13;
MEM[13].HH.LH:=0;MEM[14].HH.LH:=0;{:239}{327:}MEM[13000].HH.LH:=65535;
{:327}{481:}FOR K:=0 TO 15 DO BEGIN WINDOWOPEN[K]:=FALSE;
WINDOWTIME[K]:=0;END;{:481}{557:}MEM[13003].HH.LH:=2096;
HASH[2096].RH:=463;{:557}{703:}MEM[13002].HH.LH:=2101;{:703}{789:}
BASEIDENT:=636;{:789}{:8}END;{57:}PROCEDURE PRINTLN;
BEGIN CASE SELECTOR OF 3:BEGIN WRITELN(TERMOUT);WRITELN(LOGFILE);
TERMOFFSET:=0;FILEOFFSET:=0;END;2:BEGIN WRITELN(LOGFILE);FILEOFFSET:=0;
END;1:BEGIN WRITELN(TERMOUT);TERMOFFSET:=0;END;0,4,5:;END;END;{:57}{58:}
PROCEDURE PRINTCHAR(S:ASCIICODE);
BEGIN CASE SELECTOR OF 3:BEGIN WRITE(TERMOUT,XCHR[S]);
WRITE(LOGFILE,XCHR[S]);TERMOFFSET:=TERMOFFSET+1;
FILEOFFSET:=FILEOFFSET+1;
IF TERMOFFSET=MAXPRINTLINE THEN BEGIN WRITELN(TERMOUT);TERMOFFSET:=0;
END;IF FILEOFFSET=MAXPRINTLINE THEN BEGIN WRITELN(LOGFILE);
FILEOFFSET:=0;END;END;2:BEGIN WRITE(LOGFILE,XCHR[S]);
FILEOFFSET:=FILEOFFSET+1;IF FILEOFFSET=MAXPRINTLINE THEN PRINTLN;END;
1:BEGIN WRITE(TERMOUT,XCHR[S]);TERMOFFSET:=TERMOFFSET+1;
IF TERMOFFSET=MAXPRINTLINE THEN PRINTLN;END;0:;
4:IF TALLY<TRICKCOUNT THEN TRICKBUF[TALLY MOD ERRORLINE]:=S;
5:BEGIN IF POOLPTR<POOLSIZE THEN BEGIN STRPOOL[POOLPTR]:=S;
POOLPTR:=POOLPTR+1;END;END;END;TALLY:=TALLY+1;END;{:58}{59:}
PROCEDURE PRINT(S:INTEGER);VAR J:POOLPOINTER;
BEGIN IF(S<0)OR(S>=STRPTR)THEN S:=131 J:=STRSTART[S];
WHILE J<STRSTART[S+1]DO BEGIN PRINTCHAR(STRPOOL[J]);J:=J+1;END;END;{:59}
{61:}PROCEDURE PRINTNL(S:STRNUMBER);
BEGIN IF((TERMOFFSET>0)AND(ODD(SELECTOR)))OR((FILEOFFSET>0)AND(SELECTOR
>=2))THEN PRINTLN;PRINT(S);END;{:61}{62:}
PROCEDURE PRINTTHEDIGS(K:EIGHTBITS);BEGIN WHILE K>0 DO BEGIN K:=K-1;
IF DIG[K]<10 THEN PRINTCHAR(48+DIG[K])ELSE PRINTCHAR(55+DIG[K]);END;END;
{:62}{63:}PROCEDURE PRINTINT(N:INTEGER);VAR K:0..20;M:NONNEGATIVEI;
BEGIN K:=0;IF N<0 THEN BEGIN PRINTCHAR(45);
IF N>-100000000 THEN N:=-N ELSE BEGIN M:=-1-N;N:=M DIV 10;
M:=(M MOD 10)+1;K:=1;IF M<10 THEN DIG[0]:=M ELSE BEGIN DIG[0]:=0;N:=N+1;
END;END;END;REPEAT DIG[K]:=N MOD 10;N:=N DIV 10;K:=K+1;UNTIL N=0;
PRINTTHEDIGS(K);END;{:63}{608:}PROCEDURE PRINTFILENAM(N,A,E:INTEGER);
BEGIN PRINT(A);PRINT(N);PRINT(E);END;{:608}{72:}PROCEDURE NORMALIZESEL;
FORWARD;PROCEDURE TERMINPUT;FORWARD;PROCEDURE SHOWCONTEXT;FORWARD;
PROCEDURE BEGINFILEREA;FORWARD;PROCEDURE OPENLOGFILE;FORWARD;
PROCEDURE CLOSEFILESAN;FORWARD;PROCEDURE CLEARFORERRO;FORWARD;
{PROCEDURE DEBUGHELP;FORWARD;}{:72}{75:}PROCEDURE JUMPOUT;
BEGIN GOTO 9998;END;{:75}{76:}PROCEDURE ERROR;LABEL 22,10;
VAR C:ASCIICODE;S1,S2,S3:INTEGER;BEGIN IF HISTORY<2 THEN HISTORY:=2;
PRINTCHAR(46);SHOWCONTEXT;IF INTERACTION=3 THEN{77:}
WHILE TRUE DO BEGIN 22:CLEARFORERRO;BEGIN;PRINT(135);TERMINPUT;END;
IF LAST=FIRST THEN GOTO 10;C:=BUFFER[FIRST];IF C>=97 THEN C:=C-32;{78:}
CASE C OF 49,50,51,52,53,54,55,56,57:IF DELETIONSALL THEN{82:}
BEGIN S1:=CURCMD;S2:=CURMOD;S3:=CURSYM;OKTOINTERRUP:=FALSE;
IF(LAST>FIRST+1)AND(BUFFER[FIRST+1]>=48)AND(BUFFER[FIRST+1]<=57)THEN C:=
C*10+BUFFER[FIRST+1]-48*11 ELSE C:=C-48;WHILE C>0 DO BEGIN GETNEXT;
C:=C-1;END;CURCMD:=S1;CURMOD:=S2;CURSYM:=S3;OKTOINTERRUP:=TRUE;
BEGIN HELPPTR:=2;HELPLINE[1]:=150;HELPLINE[0]:=151;END;SHOWCONTEXT;
GOTO 22;END{:82};{68:BEGIN DEBUGHELP;GOTO 22;END;}
69:IF BASEPTR>0 THEN BEGIN PRINTNL(136);
PRINT(INPUTSTACK[BASEPTR].NAMEFIELD);PRINT(137);PRINTINT(LINE);
INTERACTION:=2;JUMPOUT;END;72:{83:}
BEGIN IF HELPPTR=0 THEN BEGIN HELPPTR:=2;HELPLINE[1]:=152;
HELPLINE[0]:=153;END;REPEAT HELPPTR:=HELPPTR-1;PRINT(HELPLINE[HELPPTR]);
PRINTLN;UNTIL HELPPTR=0;BEGIN HELPPTR:=4;HELPLINE[3]:=154;
HELPLINE[2]:=153;HELPLINE[1]:=155;HELPLINE[0]:=156;END;GOTO 22;END{:83};
73:{81:}BEGIN BEGINFILEREA;
IF LAST>FIRST+1 THEN BEGIN CURINPUT.LOCFIELD:=FIRST+1;BUFFER[FIRST]:=32;
END ELSE BEGIN BEGIN;PRINT(149);TERMINPUT;END;CURINPUT.LOCFIELD:=FIRST;
END;FIRST:=LAST+1;CURINPUT.LIMITFIELD:=LAST;GOTO 10;END{:81};
81,82,83:{80:}BEGIN ERRORCOUNT:=0;INTERACTION:=0+C-81;PRINT(144);
CASE C OF 81:BEGIN PRINT(145);SELECTOR:=SELECTOR-1;END;82:PRINT(146);
83:PRINT(147);END;PRINT(148);PRINTLN;BREAK(TERMOUT);GOTO 10;END{:80};
88:BEGIN INTERACTION:=2;JUMPOUT;END;OTHERS:END;{79:}PRINT(138);
PRINTNL(139);PRINTNL(140);IF BASEPTR>0 THEN PRINT(141);
IF DELETIONSALL THEN PRINTNL(142);PRINTNL(143){:79}{:78};END{:77};
ERRORCOUNT:=ERRORCOUNT+1;IF ERRORCOUNT=100 THEN BEGIN PRINTNL(134);
HISTORY:=3;JUMPOUT;END;{84:}IF INTERACTION>0 THEN SELECTOR:=SELECTOR-1;
IF USEERRHELP THEN BEGIN PRINTLN;GIVEERRHELP;
END ELSE WHILE HELPPTR>0 DO BEGIN HELPPTR:=HELPPTR-1;
PRINTNL(HELPLINE[HELPPTR]);END;PRINTLN;
IF INTERACTION>0 THEN SELECTOR:=SELECTOR+1;PRINTLN{:84};10:END;{:76}
{86:}PROCEDURE FATALERROR(S:STRNUMBER);BEGIN NORMALIZESEL;
BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(157);END;
BEGIN HELPPTR:=1;HELPLINE[0]:=S;END;
BEGIN IF INTERACTION=3 THEN INTERACTION:=2;ERROR;
{IF INTERACTION>0 THEN DEBUGHELP;}HISTORY:=3;JUMPOUT;END;END;{:86}{87:}
PROCEDURE OVERFLOW(S:STRNUMBER;N:INTEGER);BEGIN NORMALIZESEL;
BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(158);END;PRINT(S);
PRINTCHAR(61);PRINTINT(N);PRINTCHAR(93);BEGIN HELPPTR:=2;
HELPLINE[1]:=159;HELPLINE[0]:=160;END;
BEGIN IF INTERACTION=3 THEN INTERACTION:=2;ERROR;
{IF INTERACTION>0 THEN DEBUGHELP;}HISTORY:=3;JUMPOUT;END;END;{:87}{88:}
PROCEDURE CONFUSION(S:STRNUMBER);BEGIN NORMALIZESEL;
IF HISTORY<2 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(161);END;PRINT(S);PRINTCHAR(41);BEGIN HELPPTR:=1;HELPLINE[0]:=162;
END;END ELSE BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(163);
END;BEGIN HELPPTR:=2;HELPLINE[1]:=164;HELPLINE[0]:=165;END;END;
BEGIN IF INTERACTION=3 THEN INTERACTION:=2;ERROR;
{IF INTERACTION>0 THEN DEBUGHELP;}HISTORY:=3;JUMPOUT;END;END;{:88}{:4}
{27:}FUNCTION AOPENIN(VAR F:ALPHAFILE):BOOLEAN;
BEGIN RESET(F,NAMEOFFILE,'/O');AOPENIN:=ERSTAT(F)=0;END;
FUNCTION AOPENOUT(VAR F:ALPHAFILE):BOOLEAN;
BEGIN REWRITE(F,NAMEOFFILE,'/O');AOPENOUT:=ERSTAT(F)=0;END;
FUNCTION BOPENIN(VAR F:BYTEFILE):BOOLEAN;BEGIN RESET(F,NAMEOFFILE,'/O');
BOPENIN:=ERSTAT(F)=0;END;FUNCTION BOPENOUT(VAR F:BYTEFILE):BOOLEAN;
BEGIN REWRITE(F,NAMEOFFILE,'/O');BOPENOUT:=ERSTAT(F)=0;END;
FUNCTION WOPENIN(VAR F:WORDFILE):BOOLEAN;BEGIN RESET(F,NAMEOFFILE,'/O');
WOPENIN:=ERSTAT(F)=0;END;FUNCTION WOPENOUT(VAR F:WORDFILE):BOOLEAN;
BEGIN REWRITE(F,NAMEOFFILE,'/O');WOPENOUT:=ERSTAT(F)=0;END;{:27}{28:}
PROCEDURE ACLOSE(VAR F:ALPHAFILE);BEGIN CLOSE(F);END;
PROCEDURE BCLOSE(VAR F:BYTEFILE);BEGIN CLOSE(F);END;
PROCEDURE WCLOSE(VAR F:WORDFILE);BEGIN CLOSE(F);END;{:28}{31:}
FUNCTION INPUTLN(VAR F:ALPHAFILE;BYPASSEOLN:BOOLEAN):BOOLEAN;
VAR LASTNONBLANK:0..BUFSIZE;
BEGIN IF BYPASSEOLN THEN IF NOT EOF(F)THEN GET(F);LAST:=FIRST;
IF EOF(F)THEN INPUTLN:=FALSE ELSE BEGIN LASTNONBLANK:=FIRST;
WHILE NOT EOLN(F)DO BEGIN IF LAST>=MAXBUFSTACK THEN BEGIN MAXBUFSTACK:=
LAST+1;IF MAXBUFSTACK=BUFSIZE THEN OVERFLOW(128,BUFSIZE);END;
BUFFER[LAST]:=XORD[F↑];GET(F);LAST:=LAST+1;
IF BUFFER[LAST-1]<>32 THEN LASTNONBLANK:=LAST;END;LAST:=LASTNONBLANK;
INPUTLN:=TRUE;END;END;{:31}{37:}FUNCTION INITTERMINAL:BOOLEAN;LABEL 10;
BEGIN RESET(TERMIN,'TTY:','/O/I');WHILE TRUE DO BEGIN;
WRITE(TERMOUT,'**');BREAK(TERMOUT);
IF NOT INPUTLN(TERMIN,TRUE)THEN BEGIN WRITELN(TERMOUT);
WRITE(TERMOUT,'! End of file on the terminal... why?');
INITTERMINAL:=FALSE;GOTO 10;END;CURINPUT.LOCFIELD:=FIRST;
WHILE(CURINPUT.LOCFIELD<LAST)AND(BUFFER[CURINPUT.LOCFIELD]=32)DO
CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;
IF CURINPUT.LOCFIELD<LAST THEN BEGIN INITTERMINAL:=TRUE;GOTO 10;END;
WRITELN(TERMOUT,'Please type the name of your input file.');END;10:END;
{:37}{43:}FUNCTION MAKESTRING:STRNUMBER;
BEGIN IF STRPTR=MAXSTRINGS THEN OVERFLOW(130,MAXSTRINGS-INITSTRPTR);
STRPTR:=STRPTR+1;STRSTART[STRPTR]:=POOLPTR;MAKESTRING:=STRPTR-1;END;
{:43}{45:}FUNCTION STREQBUF(S:STRNUMBER;K:INTEGER):BOOLEAN;LABEL 45;
VAR J:POOLPOINTER;RESULT:BOOLEAN;BEGIN J:=STRSTART[S];
WHILE J<STRSTART[S+1]DO BEGIN IF STRPOOL[J]<>BUFFER[K]THEN BEGIN RESULT
:=FALSE;GOTO 45;END;J:=J+1;K:=K+1;END;RESULT:=TRUE;45:STREQBUF:=RESULT;
END;{:45}{46:}FUNCTION STREQSTR(S,T:STRNUMBER):BOOLEAN;LABEL 45;
VAR J,K:POOLPOINTER;RESULT:BOOLEAN;BEGIN RESULT:=FALSE;
IF(STRSTART[S+1]-STRSTART[S])<>(STRSTART[T+1]-STRSTART[T])THEN GOTO 45;
J:=STRSTART[S];K:=STRSTART[T];
WHILE J<STRSTART[S+1]DO BEGIN IF STRPOOL[J]<>STRPOOL[K]THEN GOTO 45;
J:=J+1;K:=K+1;END;RESULT:=TRUE;45:STREQSTR:=RESULT;END;{:46}{47:}
FUNCTION GETSTRINGSST:BOOLEAN;LABEL 30,10;VAR K,L:0..127;M,N:CHAR;
G:STRNUMBER;A:INTEGER;C:BOOLEAN;BEGIN POOLPTR:=0;STRPTR:=0;
STRSTART[0]:=0;{48:}FOR K:=0 TO 127 DO BEGIN IF({49:}
(K<32)OR(K>126){:49})THEN BEGIN BEGIN STRPOOL[POOLPTR]:=94;
POOLPTR:=POOLPTR+1;END;BEGIN STRPOOL[POOLPTR]:=94;POOLPTR:=POOLPTR+1;
END;IF K<64 THEN BEGIN STRPOOL[POOLPTR]:=K+64;POOLPTR:=POOLPTR+1;
END ELSE BEGIN STRPOOL[POOLPTR]:=K-64;POOLPTR:=POOLPTR+1;END;
END ELSE BEGIN STRPOOL[POOLPTR]:=K;POOLPTR:=POOLPTR+1;END;G:=MAKESTRING;
END{:48};{51:}NAMEOFFILE:=POOLNAME;
IF AOPENIN(POOLFILE)THEN BEGIN C:=FALSE;REPEAT{52:}
BEGIN IF EOF(POOLFILE)THEN BEGIN;
WRITELN(TERMOUT,'! MF.POOL has no check sum.');ACLOSE(POOLFILE);
GETSTRINGSST:=FALSE;GOTO 10;END;READ(POOLFILE,M,N);IF M='*'THEN{53:}
BEGIN A:=0;K:=1;
WHILE TRUE DO BEGIN IF(XORD[N]<48)OR(XORD[N]>57)THEN BEGIN;
WRITELN(TERMOUT,'! MF.POOL check sum doesn''t have nine digits.');
ACLOSE(POOLFILE);GETSTRINGSST:=FALSE;GOTO 10;END;A:=10*A+XORD[N]-48;
IF K=9 THEN GOTO 30;K:=K+1;READ(POOLFILE,N);END;
30:IF A<>207595411 THEN BEGIN;
WRITELN(TERMOUT,'! MF.POOL doesn''t match; TANGLE me again.');
ACLOSE(POOLFILE);GETSTRINGSST:=FALSE;GOTO 10;END;C:=TRUE;END{:53}
ELSE BEGIN IF(XORD[M]<48)OR(XORD[M]>57)OR(XORD[N]<48)OR(XORD[N]>57)THEN
BEGIN;WRITELN(TERMOUT,'! MF.POOL line doesn''t begin with two digits.');
ACLOSE(POOLFILE);GETSTRINGSST:=FALSE;GOTO 10;END;
L:=XORD[M]*10+XORD[N]-48*11;
IF POOLPTR+L+STRINGVACANC>POOLSIZE THEN BEGIN;
WRITELN(TERMOUT,'! You have to increase POOLSIZE.');ACLOSE(POOLFILE);
GETSTRINGSST:=FALSE;GOTO 10;END;
FOR K:=1 TO L DO BEGIN IF EOLN(POOLFILE)THEN M:=' 'ELSE READ(POOLFILE,M)
;BEGIN STRPOOL[POOLPTR]:=XORD[M];POOLPTR:=POOLPTR+1;END;END;
READLN(POOLFILE);G:=MAKESTRING;END;END{:52};UNTIL C;ACLOSE(POOLFILE);
GETSTRINGSST:=TRUE;END ELSE BEGIN;
WRITELN(TERMOUT,'! I can''t read MF.POOL.');ACLOSE(POOLFILE);
GETSTRINGSST:=FALSE;GOTO 10;END{:51};10:END;{:47}{64:}
PROCEDURE PRINTDD(N:INTEGER);BEGIN PRINTCHAR(48+((ABS(N)DIV 10)MOD 10));
PRINTCHAR(48+(ABS(N)MOD 10));END;{:64}{65:}PROCEDURE TERMINPUT;
VAR K:0..BUFSIZE;BEGIN BREAK(TERMOUT);
IF NOT INPUTLN(TERMIN,TRUE)THEN FATALERROR(132);TERMOFFSET:=0;
SELECTOR:=SELECTOR-1;
IF LAST<>FIRST THEN FOR K:=FIRST TO LAST-1 DO PRINT(BUFFER[K]);PRINTLN;
BUFFER[LAST]:=37;SELECTOR:=SELECTOR+1;END;{:65}{85:}
PROCEDURE NORMALIZESEL;
BEGIN IF JOBNAME>0 THEN SELECTOR:=3 ELSE SELECTOR:=1;
IF INTERACTION=0 THEN SELECTOR:=SELECTOR-1;
IF JOBNAME=0 THEN OPENLOGFILE;END;{:85}{91:}PROCEDURE PAUSEFORINST;
BEGIN IF OKTOINTERRUP THEN BEGIN INTERACTION:=3;
IF(SELECTOR=2)OR(SELECTOR=0)THEN SELECTOR:=SELECTOR+1;
BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(166);END;
BEGIN HELPPTR:=3;HELPLINE[2]:=167;HELPLINE[1]:=168;HELPLINE[0]:=169;END;
DELETIONSALL:=FALSE;ERROR;DELETIONSALL:=TRUE;INTERRUPT:=0;END;END;{:91}
{96:}PROCEDURE CLEARARITH;BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(170);END;BEGIN HELPPTR:=4;HELPLINE[3]:=171;
HELPLINE[2]:=172;HELPLINE[1]:=173;HELPLINE[0]:=174;END;ERROR;
ARITHERROR:=FALSE;END;{:96}{98:}
FUNCTION ROUNDDECIMAL(K:SMALLNUMBER):SCALED;VAR A:INTEGER;BEGIN A:=0;
WHILE K>0 DO BEGIN K:=K-1;A:=(A+DIG[K]*131072)DIV 10;END;
ROUNDDECIMAL:=(A+1)DIV 2;END;{:98}{99:}PROCEDURE PRINTSCALED(S:SCALED);
VAR DELTA:SCALED;BEGIN IF S<0 THEN BEGIN PRINTCHAR(45);S:=-S;END;
PRINTINT(S DIV 65536);S:=10*(S MOD 65536)+5;
IF S<>5 THEN BEGIN DELTA:=10;PRINTCHAR(46);
REPEAT IF DELTA>65536 THEN S:=S+32768-(DELTA DIV 2);
PRINTCHAR(48+(S DIV 65536));S:=10*(S MOD 65536);DELTA:=DELTA*10;
UNTIL S<=DELTA;END;END;{:99}{100:}PROCEDURE PRINTTWO(X,Y:SCALED);
BEGIN PRINTCHAR(40);PRINTSCALED(X);PRINTCHAR(44);PRINTSCALED(Y);
PRINTCHAR(41);END;{:100}{103:}
FUNCTION MAKEFRACTION(P,Q:INTEGER):FRACTION;VAR F:INTEGER;N:INTEGER;
NEGATIVE:BOOLEAN;BECAREFUL:INTEGER;
BEGIN IF P>=0 THEN NEGATIVE:=FALSE ELSE BEGIN P:=-P;NEGATIVE:=TRUE;END;
IF Q<=0 THEN BEGIN IF Q=0 THEN CONFUSION(175);Q:=-Q;
NEGATIVE:=NOT NEGATIVE;END;N:=P DIV Q;P:=P MOD Q;
IF N<8 THEN N:=(N-1)*268435456 ELSE BEGIN ARITHERROR:=TRUE;
N:=1610612736;END;{104:}F:=1;REPEAT BECAREFUL:=P-Q;P:=BECAREFUL+P;
IF P>=0 THEN F:=F+F+1 ELSE BEGIN F:=F+F;P:=P+Q;END;UNTIL F>=268435456;
BECAREFUL:=P-Q;IF BECAREFUL+P>=0 THEN F:=F+1{:104};
IF NEGATIVE THEN MAKEFRACTION:=-(F+N)ELSE MAKEFRACTION:=F+N;END;{:103}
{105:}FUNCTION TAKEFRACTION(Q:INTEGER;F:FRACTION):INTEGER;VAR P:INTEGER;
NEGATIVE:BOOLEAN;N:INTEGER;BECAREFUL:INTEGER;BEGIN{106:}
IF F>=0 THEN NEGATIVE:=FALSE ELSE BEGIN F:=-F;NEGATIVE:=TRUE;END;
IF Q<0 THEN BEGIN Q:=-Q;NEGATIVE:=NOT NEGATIVE;END;{:106};
IF F<268435456 THEN N:=0 ELSE BEGIN N:=F DIV 268435456;
F:=F MOD 268435456;
IF Q<=2147483647 DIV N THEN N:=N*Q ELSE BEGIN ARITHERROR:=TRUE;
N:=2147483647-Q;END;END;F:=F+268435456;{107:}P:=134217728;
REPEAT IF ODD(F)THEN P:=(P+Q)DIV 2 ELSE P:=(P)DIV 2;F:=(F)DIV 2;
UNTIL F=1{:107};BECAREFUL:=N-2147483647;
IF BECAREFUL+P>0 THEN BEGIN ARITHERROR:=TRUE;N:=2147483647-P;END;
IF NEGATIVE THEN TAKEFRACTION:=-(N+P)ELSE TAKEFRACTION:=N+P;END;{:105}
{108:}FUNCTION VELOCITY(ST,CT,SF,CF:FRACTION;T:SCALED):FRACTION;
VAR ACC,NUM,DENOM:INTEGER;
BEGIN ACC:=TAKEFRACTION(ST-(SF DIV 16),SF-(ST DIV 16));
ACC:=TAKEFRACTION(ACC,CT-CF);NUM:=536870912+TAKEFRACTION(ACC,379625062);
DENOM:=805306368+TAKEFRACTION(CT,497706707)+TAKEFRACTION(CF,307599661);
IF T<>65536 THEN IF T>=524288 THEN NUM:=TAKEFRACTION(NUM DIV 4096,T)ELSE
NUM:=TAKEFRACTION(NUM,T*4096);
IF NUM DIV 4>=DENOM THEN VELOCITY:=1073741824 ELSE VELOCITY:=
MAKEFRACTION(NUM,DENOM);END;{:108}{109:}FUNCTION TAKESCALED(Q:SCALED;
F:SCALED):SCALED;VAR P:INTEGER;NEGATIVE:BOOLEAN;N:INTEGER;
BECAREFUL:INTEGER;BEGIN{106:}
IF F>=0 THEN NEGATIVE:=FALSE ELSE BEGIN F:=-F;NEGATIVE:=TRUE;END;
IF Q<0 THEN BEGIN Q:=-Q;NEGATIVE:=NOT NEGATIVE;END;{:106};
IF F<65536 THEN N:=0 ELSE BEGIN N:=F DIV 65536;F:=F MOD 65536;
IF Q<=2147483647 DIV N THEN N:=N*Q ELSE BEGIN ARITHERROR:=TRUE;
N:=2147483647-Q;END;END;F:=F+65536;{110:}P:=32768;
REPEAT IF ODD(F)THEN P:=(P+Q)DIV 2 ELSE P:=(P)DIV 2;F:=(F)DIV 2;
UNTIL F=1{:110};BECAREFUL:=N-2147483647;
IF BECAREFUL+P>0 THEN BEGIN ARITHERROR:=TRUE;N:=2147483647-P;END;
IF NEGATIVE THEN TAKEFRACTION:=-(N+P)ELSE TAKEFRACTION:=N+P;END;{:109}
{111:}FUNCTION MAKESCALED(P,Q:INTEGER):SCALED;VAR F:INTEGER;N:INTEGER;
NEGATIVE:BOOLEAN;BECAREFUL:INTEGER;
BEGIN IF P>=0 THEN NEGATIVE:=FALSE ELSE BEGIN P:=-P;NEGATIVE:=TRUE;END;
IF Q<=0 THEN BEGIN Q:=-Q;NEGATIVE:=NOT NEGATIVE;END;N:=P DIV Q;
P:=P MOD Q;IF N<32768 THEN N:=(N-1)*65536 ELSE BEGIN ARITHERROR:=TRUE;
N:=2147352576;END;{112:}F:=1;REPEAT BECAREFUL:=P-Q;P:=BECAREFUL+P;
IF P>=0 THEN F:=F+F+1 ELSE BEGIN F:=F+F;P:=P+Q;END;UNTIL F>=65536;
BECAREFUL:=P-Q;IF BECAREFUL+P>=0 THEN F:=F+1{:112};
IF NEGATIVE THEN MAKEFRACTION:=-(F+N)ELSE MAKEFRACTION:=F+N;END;{:111}
{113:}FUNCTION ABGEQCD(A,B,C,D:INTEGER):BOOLEAN;LABEL 10;
VAR Q,R,T:INTEGER;BEGIN{114:}IF A<0 THEN BEGIN A:=-A;B:=-B;END;
IF C<0 THEN BEGIN C:=-C;D:=-D;END;
IF D<=0 THEN BEGIN IF B>=0 THEN BEGIN ABGEQCD:=TRUE;GOTO 10;END;
IF D=0 THEN BEGIN ABGEQCD:=(A=0);GOTO 10;END;T:=A;A:=C;C:=T;T:=-B;B:=-D;
D:=T;
END ELSE IF B<=0 THEN BEGIN IF B<0 THEN IF A>0 THEN BEGIN ABGEQCD:=FALSE
;GOTO 10;END;BEGIN ABGEQCD:=(C=0);GOTO 10;END;END{:114};
WHILE TRUE DO BEGIN Q:=A DIV D;R:=C DIV B;
IF Q<>R THEN BEGIN ABGEQCD:=(Q>R);GOTO 10;END;T:=C MOD B;
IF T=0 THEN BEGIN ABGEQCD:=TRUE;GOTO 10;END;R:=A MOD D;
IF R=0 THEN BEGIN ABGEQCD:=FALSE;GOTO 10;END;A:=B;B:=R;C:=D;D:=T;END;
10:END;{:113}{115:}FUNCTION ROUNDSCALED(X:SCALED):SCALED;
BEGIN IF X>=0 THEN ROUNDSCALED:=65536*((X+32768)DIV 65536)ELSE
ROUNDSCALED:=-65536*((-X+32767)DIV 65536);END;
FUNCTION ROUNDUNSCALE(X:SCALED):INTEGER;
BEGIN IF X>=0 THEN ROUNDUNSCALE:=(X+32768)DIV 65536 ELSE ROUNDUNSCALE:=-
((-X+32767)DIV 65536);END;FUNCTION TRUNCSCALED(X:SCALED):SCALED;
BEGIN IF X>=0 THEN TRUNCSCALED:=65536*(X DIV 65536)ELSE TRUNCSCALED:=
-65536*((-X+65535)DIV 65536);END;
FUNCTION TRUNCUNSCALE(X:SCALED):INTEGER;
BEGIN IF X>=0 THEN TRUNCUNSCALE:=X DIV 65536 ELSE TRUNCUNSCALE:=-((-X
+65535)DIV 65536);END;{:115}{117:}FUNCTION SQUARERT(X:SCALED):SCALED;
VAR K:SMALLNUMBER;Y,Q:INTEGER;BEGIN IF X<=0 THEN{118:}
BEGIN IF X<0 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(176);END;PRINTSCALED(X);PRINT(177);BEGIN HELPPTR:=2;
HELPLINE[1]:=178;HELPLINE[0]:=179;END;ERROR;END;SQUARERT:=0;END{:118}
ELSE BEGIN K:=23;Q:=2;WHILE X<536870912 DO BEGIN K:=K-1;X:=X+X+X+X;END;
IF X<1073741824 THEN Y:=0 ELSE BEGIN X:=X-1073741824;Y:=1;END;
REPEAT{119:}X:=X+X;Y:=Y+Y;IF X>=1073741824 THEN BEGIN X:=X-1073741824;
Y:=Y+1;END;X:=X+X;Y:=Y+Y-Q;Q:=Q+Q;
IF X>=1073741824 THEN BEGIN X:=X-1073741824;Y:=Y+1;END;
IF Y>Q THEN BEGIN Y:=Y-Q;Q:=Q+2;END ELSE IF Y<=0 THEN BEGIN Q:=Q-2;
Y:=Y+Q;END;K:=K-1{:119};UNTIL K=0;SQUARERT:=(Q)DIV 2;END;END;{:117}
{120:}FUNCTION PYTHADD(A,B:INTEGER):INTEGER;LABEL 30;VAR R:FRACTION;
BIG:BOOLEAN;BEGIN A:=ABS(A);B:=ABS(B);IF A<B THEN BEGIN R:=B;B:=A;A:=R;
END;
IF A>0 THEN BEGIN IF A<536870912 THEN BIG:=FALSE ELSE BEGIN A:=(A+2)DIV
4;B:=(B+2)DIV 4;BIG:=TRUE;END;{121:}
WHILE TRUE DO BEGIN R:=MAKEFRACTION(B,A);R:=TAKEFRACTION(R,R);
IF R=0 THEN GOTO 30;R:=MAKEFRACTION(R,1073741824+R);
A:=A+TAKEFRACTION(A+A,R);B:=TAKEFRACTION(B,R);END;30:{:121};
IF BIG THEN IF A<536870912 THEN A:=A+A+A+A ELSE BEGIN ARITHERROR:=TRUE;
A:=2147483647;END;END;PYTHADD:=A;END;{:120}{125:}
FUNCTION MLOG(X:SCALED):SCALED;VAR Y,Z:INTEGER;K:INTEGER;
BEGIN IF X<=0 THEN{127:}BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(180);END;PRINTSCALED(X);PRINT(177);BEGIN HELPPTR:=2;
HELPLINE[1]:=181;HELPLINE[0]:=179;END;ERROR;MLOG:=0;END{:127}
ELSE BEGIN Y:=1302456860;Z:=6581195;WHILE X<1073741824 DO BEGIN X:=X+X;
Y:=Y-93032639;Z:=Z-48782;END;Y:=Y+(Z DIV 65536);K:=2;
WHILE X>1073741828 DO{126:}BEGIN Z:=((X-1)DIV TWOTOTHE[K])+1;
WHILE X<1073741824+Z DO BEGIN Z:=(Z+1)DIV 2;K:=K+1;END;Y:=Y+SPECLOG[K];
X:=X-Z;END{:126};MLOG:=Y DIV 8;END;END;{:125}{128:}
FUNCTION MEXP(X:SCALED):SCALED;VAR K:SMALLNUMBER;Y,Z:INTEGER;
BEGIN IF X>174436200 THEN BEGIN ARITHERROR:=TRUE;MEXP:=2147483647;
END ELSE IF X<-197694359 THEN MEXP:=0 ELSE BEGIN IF X<=0 THEN BEGIN Z:=
-8*X;Y:=1048576;
END ELSE BEGIN IF X<=127919879 THEN Z:=1023359037-8*X ELSE Z:=8*(
174436200-X);Y:=2147483647;END;{129:}K:=1;
WHILE Z>0 DO BEGIN WHILE Z>=SPECLOG[K]DO BEGIN Z:=Z-SPECLOG[K];
Y:=Y-1-((Y-TWOTOTHE[K-1])DIV TWOTOTHE[K]);END;K:=K+1;END{:129};
IF X<=127919879 THEN MEXP:=(Y+8)DIV 16 ELSE MEXP:=Y;END;END;{:128}{132:}
FUNCTION NATAN(X,Y:INTEGER):ANGLE;VAR Z:ANGLE;T:INTEGER;K:SMALLNUMBER;
OCTANT:SMALLNUMBER;BEGIN IF X>=0 THEN OCTANT:=1 ELSE BEGIN X:=-X;
OCTANT:=2;END;IF Y<0 THEN BEGIN Y:=-Y;OCTANT:=OCTANT+2;END;
IF X<Y THEN BEGIN T:=Y;Y:=X;X:=T;OCTANT:=OCTANT+4;END;IF X=0 THEN{133:}
BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(182);END;
BEGIN HELPPTR:=2;HELPLINE[1]:=183;HELPLINE[0]:=179;END;ERROR;NATAN:=0;
END{:133}ELSE BEGIN{135:}WHILE X>=536870912 DO BEGIN X:=(X)DIV 2;
Y:=(Y)DIV 2;END;Z:=0;
IF Y>0 THEN BEGIN WHILE X<268435456 DO BEGIN X:=X+X;Y:=Y+Y;END;{136:}
K:=0;REPEAT Y:=Y+Y;K:=K+1;IF Y>X THEN BEGIN Z:=Z+SPECATAN[K];T:=X;
X:=X+(Y DIV TWOTOTHE[K+K]);Y:=Y-T;END;UNTIL K=15;REPEAT Y:=Y+Y;K:=K+1;
IF Y>X THEN BEGIN Z:=Z+SPECATAN[K];Y:=Y-X;END;UNTIL K=26{:136};END{:135}
;{134:}CASE OCTANT OF 1:NATAN:=Z;5:NATAN:=94371840-Z;
6:NATAN:=94371840+Z;2:NATAN:=188743680-Z;4:NATAN:=Z-188743680;
8:NATAN:=-Z-94371840;7:NATAN:=Z-94371840;3:NATAN:=-Z;END{:134};END;END;
{:132}{138:}PROCEDURE NSINCOS(Z:ANGLE);VAR K:SMALLNUMBER;Q:0..7;
R:FRACTION;X,Y,T:INTEGER;BEGIN WHILE Z<0 DO Z:=Z+377487360;
Z:=Z MOD 377487360;Q:=Z DIV 47185920;Z:=Z MOD 47185920;X:=268435456;
Y:=X;IF NOT ODD(Q)THEN Z:=47185920-Z;{140:}K:=1;
WHILE Z>0 DO BEGIN IF Z>=SPECATAN[K]THEN BEGIN Z:=Z-SPECATAN[K];T:=X;
X:=T+Y DIV TWOTOTHE[K];Y:=Y-T DIV TWOTOTHE[K];END;K:=K+1;END;
IF Y<0 THEN Y:=0{:140};{139:}CASE Q OF 0:;1:BEGIN T:=X;X:=Y;Y:=T;END;
2:BEGIN T:=X;X:=-Y;Y:=T;END;3:X:=-X;4:BEGIN X:=-X;Y:=-Y;END;
5:BEGIN T:=X;X:=-Y;Y:=-T;END;6:BEGIN T:=X;X:=Y;Y:=-T;END;7:Y:=-Y;
END{:139};R:=PYTHADD(X,Y);NCOS:=MAKEFRACTION(X,R);
NSIN:=MAKEFRACTION(Y,R);END;{:138}{142:}PROCEDURE NEWRANDOMS;
VAR K:0..54;X:FRACTION;
BEGIN FOR K:=0 TO 23 DO BEGIN X:=RANDOMS[K]-RANDOMS[K+31];
IF X<0 THEN X:=X+268435456;RANDOMS[K]:=X;END;
FOR K:=24 TO 54 DO BEGIN X:=RANDOMS[K]-RANDOMS[K-24];
IF X<0 THEN X:=X+268435456;RANDOMS[K]:=X;END;JRANDOM:=54;END;{:142}
{143:}PROCEDURE INITRANDOMS(SEED:SCALED);VAR J,JJ,K:FRACTION;I:0..54;
BEGIN J:=ABS(SEED);WHILE J>=268435456 DO J:=(J)DIV 2;K:=1;
FOR I:=0 TO 54 DO BEGIN JJ:=K;K:=J-K;J:=JJ;IF K<0 THEN K:=K+268435456;
RANDOMS[(I+21)MOD 55]:=J;END;NEWRANDOMS;NEWRANDOMS;NEWRANDOMS;END;{:143}
{144:}FUNCTION UNIFRAND(X:SCALED):SCALED;VAR Y:SCALED;
BEGIN IF X<=0 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(184);END;PRINTSCALED(X);PRINT(177);BEGIN HELPPTR:=2;
HELPLINE[1]:=185;HELPLINE[0]:=179;END;ERROR;UNIFRAND:=0;
END ELSE BEGIN IF JRANDOM=0 THEN NEWRANDOMS ELSE JRANDOM:=JRANDOM-1;
Y:=TAKEFRACTION(X,RANDOMS[JRANDOM]);
IF Y=X THEN UNIFRAND:=0 ELSE UNIFRAND:=Y;END;END;{:144}{145:}
FUNCTION NORMRAND:SCALED;VAR X,U,L:INTEGER;
BEGIN REPEAT REPEAT IF JRANDOM=0 THEN NEWRANDOMS ELSE JRANDOM:=JRANDOM-1
;X:=TAKEFRACTION(112429,RANDOMS[JRANDOM]-134217728);
IF JRANDOM=0 THEN NEWRANDOMS ELSE JRANDOM:=JRANDOM-1;
U:=RANDOMS[JRANDOM];UNTIL ABS(X)<U;X:=MAKEFRACTION(X,U);
L:=139548960-MLOG(U);UNTIL ABGEQCD(1024,L,X,X);NORMRAND:=X;END;{:145}
{150:}{PROCEDURE PRINTWORD(W:MEMORYWORD);BEGIN PRINTINT(W.INT);
PRINTCHAR(32);PRINTSCALED(W.INT);PRINTCHAR(32);PRINTLN;
PRINTINT(W.HH.LH);PRINTCHAR(61);PRINTINT(W.HH.B0);PRINTCHAR(58);
PRINTINT(W.HH.B1);PRINTCHAR(59);PRINTINT(W.HH.RH);PRINTCHAR(32);
PRINTINT(W.QQQQ.B0);PRINTCHAR(58);PRINTINT(W.QQQQ.B1);PRINTCHAR(58);
PRINTINT(W.QQQQ.B2);PRINTCHAR(58);PRINTINT(W.QQQQ.B3);END;}{:150}{155:}
{205:}PROCEDURE SHOWTOKENLIS(P,Q:INTEGER;L:INTEGER);LABEL 10;
VAR CLASS,C:SMALLNUMBER;R,V:INTEGER;BEGIN CLASS:=3;TALLY:=0;
WHILE(P<>0)AND(TALLY<L)DO BEGIN IF P=Q THEN{515:}
BEGIN FIRSTCOUNT:=TALLY;TRICKCOUNT:=TALLY+1+ERRORLINE-HALFERRORLIN;
IF TRICKCOUNT<ERRORLINE THEN TRICKCOUNT:=ERRORLINE;END{:515};{206:}C:=9;
IF(P<20)OR(P>MEMEND)THEN BEGIN PRINT(330);GOTO 10;END;
IF P<13000 THEN{207:}IF MEM[P].HH.LH=11 THEN{208:}
BEGIN IF CLASS=0 THEN PRINTCHAR(32);V:=MEM[P+1].INT;
IF V<0 THEN BEGIN IF CLASS=17 THEN PRINTCHAR(32);PRINTCHAR(91);
PRINTSCALED(V);PRINTCHAR(93);C:=18;END ELSE BEGIN PRINTSCALED(V);C:=0;
END;END{:208}ELSE IF MEM[P].HH.LH=12 THEN BEGIN PRINTCHAR(34);
PRINT(MEM[P+1].INT);PRINTCHAR(34);C:=4;END ELSE PRINT(333){:207}
ELSE BEGIN R:=MEM[P].HH.LH;IF R>=2101 THEN{210:}
BEGIN IF R<2101+PARAMSIZE THEN BEGIN PRINT(335);R:=R-(2101);
END ELSE IF R<2101+PARAMSIZE+PARAMSIZE THEN BEGIN PRINT(336);
R:=R-(2101+PARAMSIZE);END ELSE BEGIN PRINT(337);
R:=R-(2101+PARAMSIZE+PARAMSIZE);END;PRINTINT(R);C:=0;END{:210}
ELSE IF R<1 THEN IF R=0 THEN{209:}BEGIN IF CLASS=17 THEN PRINTCHAR(32);
PRINT(334);C:=18;END{:209}ELSE PRINT(331)ELSE BEGIN R:=HASH[R].RH;
IF(R<32)OR(R>=STRPTR)THEN PRINT(332)ELSE{211:}
BEGIN C:=CHARCLASS[STRPOOL[STRSTART[R]]];
IF C=CLASS THEN CASE C OF 9:PRINTCHAR(46);5,6,7,8:;
OTHERS:PRINTCHAR(32)END;PRINT(R);END{:211};END;END{:206};CLASS:=C;
P:=MEM[P].HH.RH;END;IF P<>0 THEN PRINT(329);10:END;{:205}{531:}
FIXTHIS{:531}{:155}{156:}FUNCTION GETAVAIL:HALFWORD;VAR P:HALFWORD;
BEGIN P:=AVAIL;
IF P<>0 THEN AVAIL:=MEM[AVAIL].HH.RH ELSE IF MEMEND<MEMMAX THEN BEGIN
MEMEND:=MEMEND+1;P:=MEMEND;END ELSE BEGIN RUNAWAY;
OVERFLOW(186,MEMMAX-12999);END;MEM[P].HH.RH:=0;{DYNUSED:=DYNUSED+1;}
GETAVAIL:=P;END;{:156}{160:}FUNCTION GETNODE(S:INTEGER):HALFWORD;
LABEL 40,10;VAR P:HALFWORD;Q:HALFWORD;R:INTEGER;BEGIN P:=ROVER;
REPEAT{162:}Q:=P+MEM[P].HH.LH;
WHILE(MEM[Q].HH.RH=65535)DO BEGIN IF Q=ROVER THEN ROVER:=MEM[Q+1].HH.RH;
MEM[MEM[Q+1].HH.RH+1].HH.LH:=MEM[Q+1].HH.LH;
MEM[MEM[Q+1].HH.LH+1].HH.RH:=MEM[Q+1].HH.RH;Q:=Q+MEM[Q].HH.LH;END;
R:=Q-S;IF R>P+1 THEN{163:}BEGIN MEM[P].HH.LH:=R-P;ROVER:=P;GOTO 40;
END{:163};
IF(R=P)AND((MEM[P+1].HH.RH<>ROVER)OR(MEM[P+1].HH.LH<>ROVER))THEN{164:}
BEGIN IF P=ROVER THEN ROVER:=MEM[P+1].HH.RH;
MEM[MEM[P+1].HH.RH+1].HH.LH:=MEM[P+1].HH.LH;
MEM[MEM[P+1].HH.LH+1].HH.RH:=MEM[P+1].HH.RH;ROVER:=MEM[P+1].HH.RH;
GOTO 40;END{:164};MEM[P].HH.LH:=Q-P{:162};P:=MEM[P+1].HH.RH;
UNTIL P=ROVER;IF S=1073741824 THEN BEGIN GETNODE:=65535;GOTO 10;END;
OVERFLOW(187,13000);40:MEM[R].HH.RH:=0;{VARUSED:=VARUSED+S;
IF VARUSED>MAXVARUSED THEN MAXVARUSED:=VARUSED;}GETNODE:=R;10:END;{:160}
{165:}PROCEDURE FREENODE(P:HALFWORD;S:HALFWORD);VAR Q:HALFWORD;
BEGIN IF{168:}(P<20)OR(P>=13000){:168}THEN CONFUSION(188);
MEM[P].HH.LH:=S;MEM[P].HH.RH:=65535;Q:=MEM[ROVER+1].HH.LH;
MEM[P+1].HH.LH:=Q;MEM[P+1].HH.RH:=ROVER;MEM[ROVER+1].HH.LH:=P;
MEM[Q+1].HH.RH:=P;{VARUSED:=VARUSED-S;}END;{:165}{166:}
PROCEDURE SORTAVAIL;VAR P,Q,R:HALFWORD;OLDROVER:HALFWORD;
BEGIN P:=GETNODE(1073741824);P:=MEM[ROVER+1].HH.RH;
MEM[ROVER+1].HH.RH:=65535;OLDROVER:=ROVER;WHILE P<>OLDROVER DO{167:}
IF P<ROVER THEN BEGIN Q:=P;P:=MEM[Q+1].HH.RH;MEM[Q+1].HH.RH:=ROVER;
ROVER:=Q;END ELSE BEGIN Q:=ROVER;
WHILE MEM[Q+1].HH.RH<P DO Q:=MEM[Q+1].HH.RH;R:=MEM[P+1].HH.RH;
MEM[P+1].HH.RH:=MEM[Q+1].HH.RH;MEM[Q+1].HH.RH:=P;P:=R;END{:167};
P:=ROVER;
WHILE MEM[P+1].HH.RH<>65535 DO BEGIN MEM[MEM[P+1].HH.RH+1].HH.LH:=P;
P:=MEM[P+1].HH.RH;END;MEM[P+1].HH.RH:=ROVER;MEM[ROVER+1].HH.LH:=P;END;
{:166}{171:}PROCEDURE FLUSHLIST(P:HALFWORD);VAR Q:HALFWORD;
BEGIN WHILE P>=13004 DO BEGIN Q:=MEM[P].HH.RH;BEGIN MEM[P].HH.RH:=AVAIL;
AVAIL:=P;{DYNUSED:=DYNUSED-1;}END;P:=Q;END;END;
PROCEDURE FLUSHNODELIS(P:HALFWORD);VAR Q:HALFWORD;
BEGIN WHILE P<>0 DO BEGIN Q:=P;P:=MEM[P].HH.RH;
IF Q<13000 THEN FREENODE(Q,2)ELSE BEGIN MEM[Q].HH.RH:=AVAIL;AVAIL:=Q;
{DYNUSED:=DYNUSED-1;}END;END;END;{:171}{174:}
{PROCEDURE CHECKMEM(PRINTLOCS:BOOLEAN);LABEL 31,32;VAR P,Q:HALFWORD;
CLOBBERED:BOOLEAN;BEGIN FOR P:=0 TO MEMEND DO FREE[P]:=FALSE;
[175:]P:=AVAIL;Q:=0;CLOBBERED:=FALSE;
WHILE P<>0 DO BEGIN IF(P>MEMEND)OR(P<13004)THEN CLOBBERED:=TRUE ELSE IF
FREE[P]THEN CLOBBERED:=TRUE;IF CLOBBERED THEN BEGIN PRINTNL(189);
PRINTINT(Q);GOTO 31;END;FREE[P]:=TRUE;Q:=P;P:=MEM[Q].HH.RH;END;
31:[:175];[176:]P:=ROVER;Q:=0;CLOBBERED:=FALSE;
REPEAT IF(P>=13000)OR(P<20)THEN CLOBBERED:=TRUE ELSE IF(MEM[P+1].HH.RH>=
13000)OR(MEM[P+1].HH.RH<20)THEN CLOBBERED:=TRUE ELSE IF NOT((MEM[P].HH.
RH=65535))OR(MEM[P].HH.LH<2)OR(P+MEM[P].HH.LH>13000)OR(MEM[MEM[P+1].HH.
RH+1].HH.LH<>P)THEN CLOBBERED:=TRUE;
IF CLOBBERED THEN BEGIN PRINTNL(190);PRINTINT(Q);GOTO 32;END;
FOR Q:=P TO P+MEM[P].HH.LH-1 DO BEGIN IF FREE[Q]THEN BEGIN PRINTNL(191);
PRINTINT(Q);GOTO 32;END;FREE[Q]:=TRUE;END;Q:=P;P:=MEM[P+1].HH.RH;
UNTIL P=ROVER;32:[:176];[177:]P:=0;
WHILE P<=13000 DO BEGIN IF(MEM[P].HH.RH=65535)THEN BEGIN PRINTNL(192);
PRINTINT(P);END;WHILE(P<=13000)AND NOT FREE[P]DO P:=P+1;
WHILE(P<=13000)AND FREE[P]DO P:=P+1;END[:177];
IF PRINTLOCS THEN[178:]BEGIN PRINTNL(193);
FOR P:=0 TO MEMEND DO IF NOT FREE[P]AND((P>WASMEMEND)OR WASFREE[P])THEN
BEGIN PRINTCHAR(32);PRINTINT(P);END;END[:178];
FOR P:=0 TO MEMEND DO WASFREE[P]:=FREE[P];WASMEMEND:=MEMEND;END;}{:174}
{179:}{PROCEDURE SEARCHMEM(P:HALFWORD);VAR Q:INTEGER;
BEGIN FOR Q:=0 TO MEMEND DO BEGIN IF MEM[Q].HH.RH=P THEN BEGIN PRINTNL(
194);PRINTINT(Q);PRINTCHAR(41);END;
IF MEM[Q].HH.LH=P THEN BEGIN PRINTNL(195);PRINTINT(Q);PRINTCHAR(41);END;
END;
[197:]FOR Q:=1 TO 2100 DO BEGIN IF EQTB[Q].RH=P THEN BEGIN PRINTNL(302);
PRINTINT(Q);PRINTCHAR(41);END;END[:197];END;}{:179}{181:}
PROCEDURE PRINTTYPE(T:SMALLNUMBER);BEGIN CASE T OF 1:PRINT(196);
2:PRINT(197);3:PRINT(198);4:PRINT(199);5:PRINT(200);6:PRINT(201);
7:PRINT(202);8:PRINT(203);9:PRINT(204);10:PRINT(205);11:PRINT(206);
12:PRINT(207);13:PRINT(208);14:PRINT(209);15:PRINT(210);16:PRINT(211);
17:PRINT(212);18:PRINT(213);19:PRINT(214);20:PRINT(215);21:PRINT(216);
22:PRINT(217);23:PRINT(218);OTHERS:PRINT(219)END;END;{:181}{182:}
PROCEDURE PRINTOP(C:QUARTERWORD);
BEGIN IF C<=18 THEN PRINTTYPE(C)ELSE CASE C OF 30:PRINT(220);
31:PRINT(221);32:PRINT(222);33:PRINT(223);34:PRINT(224);35:PRINT(225);
36:PRINT(226);37:PRINT(227);38:PRINT(228);39:PRINT(229);40:PRINT(230);
41:PRINT(231);42:PRINT(232);43:PRINT(233);44:PRINT(234);45:PRINT(235);
46:PRINT(236);47:PRINT(237);48:PRINT(238);49:PRINT(239);50:PRINT(240);
51:PRINT(241);52:PRINT(242);53:PRINT(243);54:PRINT(244);55:PRINT(245);
56:PRINT(246);57:PRINT(247);58:PRINT(248);59:PRINTCHAR(43);
60:PRINTCHAR(45);61:PRINTCHAR(42);62:PRINTCHAR(47);63:PRINT(249);
64:PRINT(250);65:PRINT(251);66:PRINTCHAR(60);67:PRINT(252);
68:PRINTCHAR(62);69:PRINT(253);70:PRINTCHAR(61);71:PRINT(254);
72:PRINT(255);73:PRINT(256);74:PRINT(257);75:PRINT(258);76:PRINT(259);
77:PRINT(260);78:PRINT(261);79:PRINT(262);80:PRINT(263);81:PRINT(38);
82:PRINT(264);83:PRINT(265);84:PRINT(266);85:PRINT(267);86:PRINT(268);
87:PRINT(269);88:PRINT(270);89:PRINT(271);90:PRINT(272);
OTHERS:PRINT(273)END;END;{:182}{185:}PROCEDURE BEGINDIAGNOS;
BEGIN OLDSETTING:=SELECTOR;IF HISTORY=0 THEN HISTORY:=1;
IF(INTERNAL[10]<=0)AND(SELECTOR=3)THEN SELECTOR:=SELECTOR-1;END;
PROCEDURE ENDDIAGNOSTI(BLANKLINE:BOOLEAN);BEGIN PRINTNL(300);
IF BLANKLINE THEN PRINTLN;SELECTOR:=OLDSETTING;END;{:185}{187:}
PRINTDIAGNOS(S,T:STRNUMBER)BEGIN BEGINDIAGNOS;PRINTNL(S);PRINT(137);
PRINTINT(LINE);PRINT(T);PRINTCHAR(58);END;{:187}{194:}
FUNCTION IDLOOKUP(J,L:INTEGER):HALFWORD;LABEL 40;VAR H:INTEGER;
P:HALFWORD;K:HALFWORD;BEGIN{196:}H:=BUFFER[J];
FOR K:=J+1 TO J+L-1 DO BEGIN H:=H+H+BUFFER[K];
WHILE H>=1777 DO H:=H-1777;END{:196};P:=H+1;
WHILE TRUE DO BEGIN IF HASH[P].RH>0 THEN IF(STRSTART[HASH[P].RH+1]-
STRSTART[HASH[P].RH])=L THEN IF STREQBUF(HASH[P].RH,J)THEN GOTO 40;
IF HASH[P].LH=0 THEN{195:}
BEGIN IF HASH[P].RH>0 THEN BEGIN REPEAT IF(HASHUSED=1)THEN OVERFLOW(301,
2090);HASHUSED:=HASHUSED-1;UNTIL HASH[HASHUSED].RH=0;
HASH[P].LH:=HASHUSED;P:=HASHUSED;END;
IF L=1 THEN HASH[P].RH:=BUFFER[K]ELSE BEGIN BEGIN IF POOLPTR+L>POOLSIZE
THEN OVERFLOW(129,POOLSIZE-INITPOOLPTR);END;
FOR K:=J TO J+L-1 DO BEGIN STRPOOL[POOLPTR]:=BUFFER[K];
POOLPTR:=POOLPTR+1;END;HASH[P].RH:=MAKESTRING;END;{STCOUNT:=STCOUNT+1;}
GOTO 40;END{:195};P:=HASH[P].LH;END;40:IDLOOKUP:=P;END;{:194}{198:}
PROCEDURE PRIMITIVE(S:STRNUMBER;C:HALFWORD;O:HALFWORD);
VAR K:POOLPOINTER;J:SMALLNUMBER;L:SMALLNUMBER;BEGIN K:=STRSTART[S];
L:=STRSTART[S+1]-K;FOR J:=0 TO L-1 DO BUFFER[J]:=STRPOOL[K+J];
CURSYM:=IDLOOKUP(0,L);BEGIN STRPTR:=STRPTR-1;POOLPTR:=STRSTART[STRPTR];
END;HASH[CURSYM].RH:=S;EQTB[CURSYM].LH:=C;EQTB[CURSYM].RH:=O;END;{:198}
{203:}FUNCTION NEWNUMTOK(V:SCALED):HALFWORD;VAR P:HALFWORD;
BEGIN P:=GETNODE(2);MEM[P+1].INT:=V;MEM[P].HH.LH:=11;NEWNUMTOK:=P;END;
{:203}{204:}PROCEDURE FLUSHTOKENLI(P:HALFWORD);VAR Q:HALFWORD;
BEGIN WHILE P<>0 DO BEGIN Q:=P;P:=MEM[P].HH.RH;
IF Q<13000 THEN FREENODE(Q,2)ELSE BEGIN MEM[Q].HH.RH:=AVAIL;AVAIL:=Q;
{DYNUSED:=DYNUSED-1;}END;END;END;{:204}{212:}
PROCEDURE DELETEREF(P:HALFWORD);
BEGIN IF MEM[P].HH.LH=0 THEN FLUSHTOKENLI(P)ELSE MEM[P].HH.LH:=MEM[P].HH
.LH-1;END;{:212}{215:}{495:}PROCEDURE PRINTCMDMOD(CMD:HALFWORD;
MOD:HALFWORD);BEGIN CASE CMD OF{200:}22:PRINT(38);26:PRINT(250);
59:PRINT(306);65:PRINT(304);62:PRINT(307);9:PRINT(308);64:PRINT(58);
66:PRINT(44);50:PRINT(309);53:PRINT(310);52:PRINT(311);46:PRINT(312);
37:PRINT(305);68:PRINT(313);25:PRINT(61);45:PRINT(314);60:PRINT(315);
2:PRINT(316);32:PRINT(317);57:PRINT(123);27:PRINT(91);33:PRINT(318);
58:PRINT(319);47:PRINT(320);23:PRINT(303);43:PRINT(321);6:PRINT(322);
42:PRINT(323);56:PRINT(125);55:PRINT(93);31:PRINT(324);67:PRINT(59);
36:PRINT(325);29:PRINT(47);51:PRINT(326);61:PRINT(327);63:PRINT(328);
{:200}{214:}
49:IF MOD=1 THEN PRINT(338)ELSE IF MOD=2 THEN PRINT(339)ELSE PRINT(340);
{:214}{549:}34:CASE MOD OF 1:PRINT(452);2:PRINT(453);3:PRINT(454);
4:PRINT(455);5:PRINT(456);OTHERS:PRINT(457)END;
4:IF MOD=1 THEN PRINT(458)ELSE PRINT(463);
35:IF MOD=1 THEN PRINT(460)ELSE IF MOD=2 THEN PRINT(461)ELSE PRINT(462);
{:549}{554:}MACROSPECIAL:CASE MOD OF 1:PRINT(465);2:PRINTCHAR(64);
1:PRINT(466);OTHERS:PRINT(464)END;{:554}{562:}
PARAMTYPE:IF MOD=2101 THEN PRINT(473)ELSE IF MOD=2101+PARAMSIZE THEN
PRINT(474)ELSE IF MOD=2101+PARAMSIZE+PARAMSIZE THEN PRINT(475)ELSE PRINT
(338);{:562}{572:}1:IF CHRCODE=0 THEN PRINT(480)ELSE PRINT(481);{:572}
{589:}
3:IF CHRCODE=2 THEN PRINTESC(497)ELSE IF CHRCODE=4 THEN PRINTESC(499)
ELSE PRINTESC(498);{:589}{672:}
10:IF MOD=1 THEN PRINT(531)ELSE PRINT(532);{:672}{740:}
51:IF MOD=0 THEN PRINT(589)ELSE PRINT(326);{:740}{752:}
13,14,15,30,21,24,19,22,25,26:PRINTOP(MOD);{:752}{784:}
7:CASE MOD OF 18:PRINT(213);4:PRINT(199);2:PRINT(197);11:PRINT(628);
6:PRINT(201);9:PRINT(204);13:PRINT(208);OTHERS:PRINT(209)END;{:784}
OTHERS:PRINT(415)END;END;{:495}PROCEDURE SHOWMACRO(P:HALFWORD);
VAR Q:HALFWORD;BEGIN P:=MEM[P].HH.RH;
WHILE MEM[P].HH.LH>5 DO BEGIN PRINTCHAR(40);Q:=MEM[P].HH.RH;
MEM[P].HH.RH:=0;SHOWTOKENLIS(P,0,1);MEM[P].HH.RH:=Q;PRINTCHAR(41);P:=Q;
END;CASE MEM[P].HH.LH OF 0:PRINT(341);1,2,3:BEGIN PRINTCHAR(60);
PRINTCMDMOD(49,MEM[P].HH.LH);PRINT(342);END;4:PRINT(343);5:PRINT(344);
END;SHOWTOKENLIS(MEM[P].HH.RH,0,1000);END;{:215}{219:}
PROCEDURE NEWROOT(X:HALFWORD);VAR P:HALFWORD;BEGIN P:=GETNODE(2);
MEM[P].HH.B0:=0;MEM[P].HH.B1:=0;MEM[P].HH.RH:=X;EQTB[X].RH:=P;END;{:219}
{220:}PROCEDURE INITBIGNODE(P:HALFWORD;S:SMALLNUMBER);VAR Q:HALFWORD;
BEGIN Q:=GETNODE(S);REPEAT S:=S-2;MEM[Q+S].HH.B0:=19;MEM[Q+S+1].INT:=0;
MEM[Q+S].HH.B1:=(S)DIV 2+5;MEM[Q+S].HH.RH:=0;UNTIL S=0;MEM[Q].HH.RH:=P;
MEM[P+1].INT:=Q;END;{:220}{221:}PRINTVARIABL(P:HALFWORD);LABEL 40,10;
VAR Q:HALFWORD;R:HALFWORD;BEGIN IF MEM[P].HH.B1>=5 THEN{223:}
BEGIN CASE MEM[P].HH.B1 OF 5:PRINTCHAR(120);6:PRINTCHAR(121);
7:PRINT(347);8:PRINT(348);9:PRINT(349);10:PRINT(350);
11:BEGIN PRINT(351);PRINTINT(P-0);GOTO 10;END;END;PRINT(352);
P:=MEM[P-2*(MEM[P].HH.B1-5)].HH.RH;END{:223};Q:=0;
WHILE MEM[P].HH.B1>1 DO{222:}
BEGIN IF MEM[P].HH.B1=3 THEN BEGIN R:=NEWNUMTOK(MEM[P+2].INT);
REPEAT P:=MEM[P].HH.RH;UNTIL MEM[P].HH.B1=4;
END ELSE IF MEM[P].HH.B1=2 THEN GOTO 40 ELSE BEGIN IF MEM[P].HH.B1<>4
THEN CONFUSION(346);R:=GETAVAIL;MEM[R].HH.LH:=MEM[P+2].HH.LH;END;
MEM[R].HH.RH:=Q;Q:=R;40:P:=MEM[P+2].HH.RH;END{:222};R:=GETAVAIL;
MEM[R].HH.LH:=MEM[P].HH.RH;MEM[R].HH.RH:=Q;
IF MEM[P].HH.B1=1 THEN PRINT(345);SHOWTOKENLIS(R,0,1000);
FLUSHTOKENLI(R);10:END;{:221}{224:}
FUNCTION NEWSTRUCTURE(P:HALFWORD):HALFWORD;VAR Q,R,S:HALFWORD;
BEGIN CASE MEM[P].HH.B1 OF 0:BEGIN Q:=MEM[P].HH.RH;R:=GETNODE(2);
EQTB[Q].RH:=R;END;3:{225:}BEGIN Q:=P;REPEAT Q:=MEM[Q].HH.RH;
UNTIL MEM[Q].HH.B1=4;Q:=MEM[Q+2].HH.RH;R:=Q+1;REPEAT S:=R;
R:=MEM[R].HH.RH;UNTIL R=P;R:=GETNODE(3);MEM[S].HH.RH:=R;
MEM[R+2].INT:=MEM[P+2].INT;END{:225};4:{226:}BEGIN Q:=MEM[P+2].HH.RH;
R:=MEM[Q+1].HH.LH;REPEAT S:=R;R:=MEM[R].HH.RH;UNTIL R=P;R:=GETNODE(3);
MEM[S].HH.RH:=R;MEM[R+2]:=MEM[P+2];END{:226};OTHERS:CONFUSION(353)END;
MEM[R].HH.RH:=MEM[P].HH.RH;MEM[R].HH.B0:=21;MEM[R].HH.B1:=MEM[P].HH.B1;
MEM[R+1].HH.LH:=P;MEM[P].HH.B1:=2;S:=GETNODE(3);MEM[P].HH.RH:=S;
MEM[#+1].HH.RH(R):=S;MEM[S+2].HH.RH:=R;MEM[S].HH.B0:=0;MEM[S].HH.B1:=4;
MEM[S].HH.RH:=17;MEM[S+2].HH.LH:=0;NEWSTRUCTURE:=R;END;{:224}{227:}
FUNCTION FINDVARIABLE(T:HALFWORD):HALFWORD;LABEL 10;
VAR P,Q,R,S:HALFWORD;PP,QQ,RR,SS:HALFWORD;N:INTEGER;SAVEWORD:MEMORYWORD;
BEGIN P:=MEM[T].HH.LH;T:=MEM[T].HH.RH;
IF EQTB[P].LH<>18 THEN BEGIN FINDVARIABLE:=0;GOTO 10;END;P:=EQTB[P].RH;
PP:=P;WHILE T<>0 DO BEGIN{228:}
IF MEM[PP].HH.B0<>21 THEN BEGIN IF MEM[PP].HH.B0>21 THEN BEGIN
FINDVARIABLE:=0;GOTO 10;END;SS:=NEWSTRUCTURE(PP);IF P=PP THEN P:=SS;
PP:=SS;END;IF MEM[P].HH.B0<>21 THEN P:=NEWSTRUCTURE(P){:228};
IF T<13000 THEN{229:}BEGIN N:=MEM[T+1].INT;
PP:=MEM[MEM[PP+1].HH.LH].HH.RH;Q:=MEM[MEM[P+1].HH.LH].HH.RH;
SAVEWORD:=MEM[Q+2];MEM[Q+2].INT:=2147483647;S:=P+1;REPEAT R:=S;
S:=MEM[S].HH.RH;UNTIL N<=3(S);
IF N=3(S)THEN P:=S ELSE BEGIN P:=GETNODE(3);MEM[R].HH.RH:=P;
MEM[P].HH.RH:=S;MEM[P+2].INT:=N;MEM[P].HH.B1:=3;
MEM[P].HH.B0:=MEM[PP].HH.B0;MEM[P+1].INT:=0;END;MEM[Q+2]:=SAVEWORD;
END{:229}ELSE{230:}BEGIN N:=MEM[T].HH.LH;SS:=MEM[PP+1].HH.LH;
REPEAT RR:=SS;SS:=MEM[SS].HH.RH;UNTIL N<=MEM[SS+2].HH.LH;
IF N<MEM[SS+2].HH.LH THEN BEGIN QQ:=GETNODE(3);MEM[RR].HH.RH:=QQ;
MEM[QQ].HH.RH:=SS;MEM[QQ+2].HH.LH:=N;MEM[QQ].HH.B1:=4;MEM[QQ].HH.B0:=0;
MEM[QQ+2].HH.RH:=MEM[RR+2].HH.RH;SS:=QQ;END;IF P=PP THEN BEGIN P:=SS;
PP:=SS;END ELSE BEGIN PP:=SS;S:=MEM[P+1].HH.LH;REPEAT R:=S;
S:=MEM[S].HH.RH;UNTIL N<=MEM[S+2].HH.LH;
IF N=MEM[S+2].HH.LH THEN P:=S ELSE BEGIN P:=GETNODE(3);MEM[R].HH.RH:=P;
MEM[P].HH.RH:=S;MEM[P+2].HH.LH:=N;MEM[P].HH.B1:=4;
MEM[P].HH.B0:=MEM[PP].HH.B0;MEM[P+1].INT:=0;
MEM[P+2].HH.RH:=MEM[R+2].HH.RH;END;END;END{:230};T:=MEM[T].HH.RH;END;
IF MEM[PP].HH.B0>=21 THEN IF MEM[PP].HH.B0=21 THEN PP:=MEM[PP+1].HH.LH
ELSE BEGIN FINDVARIABLE:=0;GOTO 10;END;
IF MEM[P].HH.B0=21 THEN P:=MEM[P+1].HH.LH;
IF MEM[P].HH.B0=0 THEN BEGIN IF MEM[PP].HH.B0=0 THEN MEM[PP].HH.B0:=18;
MEM[P].HH.B0:=MEM[PP].HH.B0;END;FINDVARIABLE:=P;END;{:227}{231:}{680:}
FIXTHIS{:680}{232:}PROCEDURE FLUSHBELOWVA(P:HALFWORD);
BEGIN IF MEM[P].HH.B0<>21 THEN RECYCLEVALUE(P)ELSE BEGIN Q:=MEM[#+1].HH.
RH(P);WHILE MEM[Q].HH.B1=3 DO BEGIN FLUSHBELOWVA(Q);R:=Q;
Q:=MEM[Q].HH.RH;FREENODE(R,3);END;R:=MEM[P+1].HH.LH;Q:=MEM[R].HH.RH;
RECYCLEVALUE(R);FREENODE(R,2);REPEAT FLUSHBELOWVA(Q);R:=Q;
Q:=MEM[Q].HH.RH;FREENODE(R,3);UNTIL Q=17;MEM[P].HH.B0:=0;END;END;{:232}
PROCEDURE FLUSHVARIABL(P,T:HALFWORD;DISCARDSUFFI:BOOLEAN);LABEL 10;
VAR Q,R:HALFWORD;N:HALFWORD;
BEGIN WHILE T<>0 DO BEGIN IF MEM[P].HH.B0<>21 THEN GOTO 10;
N:=MEM[T].HH.LH;T:=MEM[T].HH.RH;IF N=0 THEN BEGIN R:=P+1;
Q:=MEM[R].HH.RH;
WHILE MEM[Q].HH.B1=3 DO BEGIN FLUSHVARIABL(Q,T,DISCARDSUFFI);
IF T=0 THEN IF MEM[Q].HH.B0<>21 THEN BEGIN MEM[R].HH.RH:=MEM[Q].HH.RH;
FREENODE(Q,3);END ELSE BEGIN RECYCLEVALUE(MEM[Q+1].HH.LH);R:=Q;
END ELSE R:=Q;Q:=MEM[R].HH.RH;END;END;P:=MEM[P+1].HH.LH;REPEAT R:=P;
P:=MEM[P].HH.RH;UNTIL MEM[P].HH.LH>=N;IF MEM[P].HH.LH<>N THEN GOTO 10;
END;
IF DISCARDSUFFI THEN FLUSHBELOWVA(P)ELSE BEGIN IF MEM[P].HH.B0=21 THEN P
:=MEM[P+1].HH.LH;RECYCLEVALUE(P);END;10:END;{:231}{235:}
PROCEDURE SAVEVARIABLE(Q:HALFWORD);VAR P:HALFWORD;
BEGIN IF EQTB[Q].LH=18 THEN BEGIN P:=EQTB[Q].RH;
IF P<>0 THEN IF SAVEPTR<>0 THEN MEM[P].HH.B1:=1 ELSE BEGIN FLUSHBELOWVA(
P);FREENODE(P,2);END;;
END ELSE IF EQTB[Q].LH=5 THEN IF SAVEPTR=0 THEN DELETEREF(EQTB[Q].RH);
IF SAVEPTR<>0 THEN BEGIN P:=GETNODE(2);MEM[P].HH.LH:=Q;
MEM[P].HH.RH:=SAVEPTR;MEM[P+1].HH:=EQTB[Q];SAVEPTR:=P;END;EQTB[Q]:=2100;
END;{:235}{236:}PROCEDURE SAVEINTERNAL(Q:SMALLNUMBER);VAR P:HALFWORD;
BEGIN IF SAVEPTR<>0 THEN BEGIN P:=GETNODE(2);MEM[P].HH.LH:=2100+Q;
MEM[P].HH.RH:=SAVEPTR;MEM[P+1].INT:=INTERNAL[Q];SAVEPTR:=P;END;END;
{:236}{237:}PROCEDURE UNSAVE;VAR Q:HALFWORD;P:HALFWORD;
BEGIN WHILE MEM[SAVEPTR].HH.LH<>0 DO BEGIN Q:=MEM[SAVEPTR].HH.LH;
IF Q>2100 THEN BEGIN INTERNAL[Q-2100]:=MEM[SAVEPTR+1].INT;
END ELSE BEGIN IF EQTB[Q].LH=18 THEN BEGIN P:=EQTB[Q].RH;
IF P<>0 THEN BEGIN FLUSHBELOWVA(P);FREENODE(P,2);END;;
END ELSE IF EQTB[Q].LH=5 THEN DELETEREF(EQTB[Q].RH);
EQTB[Q]:=MEM[SAVEPTR+1].HH;IF EQTB[Q].LH=18 THEN BEGIN P:=EQTB[Q].RH;
IF P<>0 THEN MEM[P].HH.B1:=0;END;END;P:=MEM[SAVEPTR].HH.RH;
FREENODE(SAVEPTR,2);SAVEPTR:=P;END;P:=MEM[SAVEPTR].HH.RH;
BEGIN MEM[SAVEPTR].HH.RH:=AVAIL;AVAIL:=SAVEPTR;{DYNUSED:=DYNUSED-1;}END;
SAVEPTR:=P;END;{:237}{241:}
PROCEDURE PRINTDEPENDE(P:HALFWORD,T:SMALLNUMBER);LABEL 50,10;
VAR V:INTEGER;PP,Q:HALFWORD;BEGIN PP:=P;
WHILE TRUE DO BEGIN V:=ABS(MEM[P+1].INT);Q:=MEM[P].HH.LH;
IF Q=0 THEN BEGIN IF(V<>0)OR(P=PP)THEN BEGIN IF MEM[P+1].INT>0 THEN IF P
<>PP THEN PRINTCHAR(43);PRINTSCALED(MEM[P+1].INT);END;GOTO 10;END;
IF T=16 THEN BEGIN IF V<>268435456 THEN BEGIN PRINTSCALED(MEM[P+1].INT
DIV 4096);GOTO 50;END;
END ELSE IF V<>65536 THEN BEGIN PRINTSCALED(MEM[P+1].INT);GOTO 50;END;
IF MEM[P+1].INT>0 THEN PRINTCHAR(43)ELSE PRINTCHAR(45);
50:IF MEM[P].HH.B0<>19 THEN CONFUSION(354);PRINTVARIABL(Q);
V:=MEM[Q+1].INT;WHILE V>0 DO BEGIN PRINT(355);V:=V-2;END;
P:=MEM[P].HH.RH;END;10:END;{:241}{242:}
FUNCTION MAXCOEF(P:HALFWORD):FRACTION;VAR X:FRACTION;BEGIN X:=0;
WHILE MEM[P].HH.LH<>0 DO BEGIN IF ABS(MEM[P+1].INT)>X THEN X:=ABS(MEM[P
+1].INT);P:=MEM[P].HH.RH;END;MAXCOEF:=X;END;{:242}{245:}
FUNCTION PPLUSFQ(P:HALFWORD;F:INTEGER;Q:HALFWORD;
T:SMALLNUMBER):HALFWORD;LABEL 30;VAR PP,QQ:HALFWORD;R,S:HALFWORD;
THRESHOLD:INTEGER;BEGIN IF T=16 THEN THRESHOLD:=2685 ELSE THRESHOLD:=8;
R:=13001;PP:=MEM[P].HH.LH;QQ:=MEM[Q].HH.LH;
WHILE TRUE DO IF PP=QQ THEN IF PP=0 THEN GOTO 30 ELSE{246:}
BEGIN V:=MEM[P+1].INT+TAKEFRACTION(F,MEM[Q+1].INT);MEM[P+1].INT:=V;S:=P;
P:=MEM[P].HH.RH;PP:=MEM[P].HH.LH;Q:=MEM[Q].HH.RH;QQ:=MEM[Q].HH.LH;
IF ABS(V)<THRESHOLD THEN FREENODE(S,2)ELSE BEGIN IF ABS(V)>=626349397
THEN BEGIN MEM[QQ].HH.B0:=0;FIXNEEDED:=TRUE;END;MEM[R].HH.RH:=S;R:=S;
END;END{:246}ELSE IF PP<QQ THEN{247:}
BEGIN V:=TAKEFRACTION(F,MEM[Q+1].INT);
IF ABS(V)>(THRESHOLD)DIV 2 THEN BEGIN S:=GETNODE(2);MEM[S].HH.LH:=QQ;
MEM[S+1].INT:=V;IF ABS(V)>=626349397 THEN BEGIN MEM[QQ].HH.B0:=0;
FIXNEEDED:=TRUE;END;MEM[R].HH.RH:=S;R:=S;END;END{:247}
ELSE BEGIN MEM[R].HH.RH:=P;R:=P;P:=MEM[P].HH.RH;PP:=MEM[P].HH.LH;END;
30:IF T=16 THEN MEM[P+1].INT:=MEM[P+1].INT+TAKEFRACTION(MEM[Q+1].INT,F)
ELSE MEM[P+1].INT:=MEM[P+1].INT+TAKESCALED(MEM[Q+1].INT,F);DEPTAIL:=P;
PPLUSFQ:=MEM[13001].HH.RH;END;{:245}{248:}FUNCTION PTIMESV(P:HALFWORD;
V:INTEGER;T0,T1:SMALLNUMBER;VISSCALED:BOOLEAN):HALFWORD;
VAR R,S:HALFWORD;W:INTEGER;THRESHOLD:INTEGER;SCALINGDOWN:BOOLEAN;
BEGIN IF T0<>T1 THEN SCALINGDOWN:=TRUE ELSE SCALINGDOWN:=NOT VISSCALED;
IF T1=16 THEN THRESHOLD:=1342 ELSE THRESHOLD:=4;R:=13001;
WHILE MEM[P].HH.LH<>0 DO BEGIN IF SCALINGDOWN THEN W:=TAKEFRACTION(V,MEM
[P+1].INT)ELSE W:=TAKESCALED(V,MEM[P+1].INT);
IF ABS(W)<=THRESHOLD THEN BEGIN S:=MEM[P].HH.RH;FREENODE(P,2);P:=S;
END ELSE BEGIN IF ABS(W)>=626349397 THEN BEGIN FIXNEEDED:=TRUE;
MEM[MEM[P].HH.LH].HH.B0:=0;END;MEM[R].HH.RH:=P;R:=P;MEM[P+1].INT:=W;
P:=MEM[P].HH.RH;END;END;MEM[R].HH.RH:=P;
IF VISSCALED THEN MEM[P+1].INT:=TAKESCALED(MEM[P+1].INT,V)ELSE MEM[P+1].
INT:=TAKEFRACTION(MEM[P+1].INT,V);PTIMESV:=MEM[13001].HH.RH;END;{:248}
{249:}FUNCTION POVERV(P:HALFWORD;V:SCALED;T0,T1:SMALLNUMBER):HALFWORD;
VAR R,S:HALFWORD;W:INTEGER;THRESHOLD:INTEGER;SCALINGDOWN:BOOLEAN;
BEGIN IF T0<>T1 THEN SCALINGDOWN:=TRUE ELSE SCALINGDOWN:=FALSE;
IF T1=16 THEN THRESHOLD:=1342 ELSE THRESHOLD:=4;R:=13001;
WHILE MEM[P].HH.LH<>0 DO BEGIN IF SCALINGDOWN THEN W:=MAKESCALED(MEM[P+1
].INT DIV 4096,V)ELSE W:=MAKESCALED(MEM[P+1].INT,V);
IF ABS(W)<=THRESHOLD THEN BEGIN S:=MEM[P].HH.RH;FREENODE(P,2);P:=S;
END ELSE BEGIN IF ABS(W)>=626349397 THEN BEGIN FIXNEEDED:=TRUE;
MEM[MEM[P].HH.LH].HH.B0:=0;END;MEM[R].HH.RH:=P;R:=P;MEM[P+1].INT:=W;
P:=MEM[P].HH.RH;END;END;MEM[R].HH.RH:=P;
MEM[P+1].INT:=MAKESCALED(V,MEM[P+1].INT);POVERV:=MEM[13001].HH.RH;END;
{:249}{250:}FUNCTION PWITHXBECOMI(P:HALFWORD;F:INTEGER;Q:HALFWORD;
T:SMALLNUMBER):HALFWORD;VAR R,S:HALFWORD;V:INTEGER;BEGIN S:=P;R:=13001;
WHILE MEM[S].HH.LH>Q DO BEGIN R:=S;S:=MEM[S].HH.RH;END;
IF MEM[S].HH.LH<>Q THEN PWITHXBECOMI:=P ELSE BEGIN MEM[13001].HH.RH:=P;
MEM[R].HH.RH:=MEM[S].HH.RH;V:=MEM[S+1].INT;FREENODE(S,2);
PWITHXBECOMI:=PPLUSFQ(MEM[13001].HH.RH,V,Q,T);END;END;{:250}{251:}
PROCEDURE FIXDEPENDENC;VAR P,R,S:HALFWORD;X:HALFWORD;
BEGIN R:=MEM[13].HH.RH;S:=0;WHILE R<>13 DO BEGIN R:=MEM[R+1].HH.LH;
WHILE TRUE DO BEGIN X:=MEM[R].HH.LH;IF X=0 THEN GOTO 30;
IF MEM[X].HH.B0<=1 THEN BEGIN IF MEM[X].HH.B0<1 THEN BEGIN P:=GETAVAIL;
MEM[P].HH.RH:=S;S:=P;MEM[S].HH.LH:=X;MEM[X].HH.B0:=1;END;
MEM[R+1].INT:=MEM[R+1].INT DIV 4;END;R:=MEM[R].HH.RH;END;
30:R:=MEM[R].HH.RH;END;WHILE S<>0 DO BEGIN P:=MEM[S].HH.RH;
X:=MEM[S].HH.LH;BEGIN MEM[S].HH.RH:=AVAIL;AVAIL:=S;{DYNUSED:=DYNUSED-1;}
END;S:=P;MEM[X].HH.B0:=19;MEM[X+1].INT:=MEM[X+1].INT+2;END;END;{:251}
{252:}PROCEDURE NEWEQ(LHS,RHS:HALFWORD);LABEL 10;
VAR BEGIN P:=PPLUSFQ(LHS,-65536,RHS,17);IF MEM[P].HH.LH=0 THEN{253:}
BEGIN IF ABS(MEM[P+1].INT)>=8 THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(356);END;BEGIN HELPPTR:=2;HELPLINE[1]:=357;
HELPLINE[0]:=358;END;END ELSE BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(359);END;BEGIN HELPPTR:=2;HELPLINE[1]:=360;
HELPLINE[0]:=361;END;END;ERROR;FREENODE(P,2);GOTO 10;END{:253};{254:}
Q:=P;R:=MEM[P].HH.RH;V:=MEM[Q+1].INT;
WHILE MEM[R].HH.LH<>0 DO BEGIN IF ABS(MEM[R+1].INT)>ABS(V)THEN BEGIN Q:=
R;V:=MEM[R+1].INT;END;R:=MEM[R].HH.RH;END{:254};X:=MEM[Q].HH.LH;
N:=MEM[X+1].INT;{255:}S:=13001;MEM[S].HH.RH:=P;R:=P;
REPEAT IF R=Q THEN BEGIN MEM[S].HH.RH:=MEM[R].HH.RH;FREENODE(R,2);
END ELSE BEGIN W:=MAKEFRACTION(MEM[R+1].INT,V);
IF ABS(W)<=1342 THEN BEGIN MEM[S].HH.RH:=MEM[R].HH.RH;FREENODE(R,2);
END ELSE BEGIN MEM[R+1].INT:=-W;S:=R;END;END;R:=MEM[S].HH.RH;
UNTIL MEM[R].HH.LH=0;
IF V=65536 THEN MEM[R+1].INT:=-MEM[R+1].INT ELSE MEM[R+1].INT:=
TAKEFRACTION(MEM[R+1].INT,MAKEFRACTION(-65536,V));
P:=MEM[13001].HH.RH{:255};IF INTERNAL[2]THEN{256:}BEGIN PRINTNL(362);
PRINTVARIABL(X);W:=N;WHILE W>0 DO BEGIN PRINT(355);W:=W-2;END;
PRINTCHAR(61);PRINTDEPENDE(P,16);END{:256};{257:}PREVR:=13;
R:=MEM[13].HH.RH;WHILE R<>13 DO BEGIN S:=MEM[R+1].HH.LH;
Q:=PWITHXBECOMI(S,X,P,MEM[R].HH.B0);
IF(MEM[Q].HH.LH=0)AND(MEM[R].HH.B0=16)THEN{258:}BEGIN MEM[R].HH.B0:=15;
MEM[R+1].INT:=MEM[Q+1].INT;IF INTERNAL[2]>0 THEN BEGIN PRINTNL(363);
PRINTVARIABL(R);PRINTCHAR(61);PRINTSCALED(MEM[R+1].INT);END;
R:=MEM[Q].HH.RH;MEM[#+1].HH.RH(R):=PREVR;MEM[PREVR].HH.RH:=R;
FREENODE(Q,2);END{:258}ELSE BEGIN MEM[R+1].HH.LH:=Q;
REPEAT Q:=MEM[Q].HH.RH;UNTIL MEM[Q].HH.LH=0;PREVR:=Q;R:=MEM[Q].HH.RH;
END;END{:257};{259:}IF N>0 THEN{260:}BEGIN S:=13001;MEM[S].HH.RH:=P;
R:=P;REPEAT IF N>30 THEN W:=0 ELSE W:=MEM[R+1].INT DIV TWOTOTHE[N];
IF(ABS(W)<=1342)AND(MEM[R].HH.LH<>0)THEN BEGIN MEM[S].HH.RH:=MEM[R].HH.
RH;FREENODE(R,2);END ELSE BEGIN MEM[R+1].INT:=W;S:=R;END;
R:=MEM[S].HH.RH;UNTIL MEM[S].HH.LH=0;P:=MEM[13001].HH.RH;END{:260};
IF MEM[P].HH.LH=0 THEN BEGIN MEM[X].HH.B0:=15;
MEM[X+1].INT:=MEM[P+1].INT;FREENODE(P,2);
END ELSE BEGIN MEM[X].HH.B0:=16;MEM[X+1].HH.LH:=P;MEM[#+1].HH.RH(X):=13;
Q:=P;REPEAT Q:=MEM[Q].HH.RH;UNTIL MEM[Q].HH.LH=0;
MEM[Q].HH.RH:=MEM[13].HH.RH;MEM[#+1].HH.RH(MEM[13].HH.RH):=Q;
MEM[13].HH.RH:=X;END{:259};IF FIXNEEDED THEN FIXDEPENDENC;10:END;{:252}
{262:}FUNCTION NEWRINGENTRY(P:HALFWORD):HALFWORD;VAR Q:HALFWORD;
BEGIN Q:=GETNODE(2);MEM[Q].HH.B1:=11;MEM[Q].HH.B0:=MEM[P].HH.B0;
IF MEM[P+1].INT=0 THEN MEM[Q+1].INT:=P ELSE MEM[Q+1].INT:=MEM[P+1].INT;
MEM[P+1].INT:=Q;NEWRINGENTRY:=Q;END;{:262}{266:}
PROCEDURE PRINTPATH(H:HALFWORD;S:STRNUMBER);LABEL 30,31;
VAR P,Q,R:HALFWORD;BEGIN PRINTDIAGNOS(364,S);
IF MEM[H].HH.B0=5 THEN{267:}BEGIN PRINTTWO(MEM[H+1].INT,MEM[H+2].INT);
IF MEM[H].HH.B1=3 THEN BEGIN PRINT(368);PRINTSCALED(MEM[H+5].INT);
END ELSE BEGIN PRINTCHAR(123);PRINTSCALED(MEM[H+5].INT);PRINTCHAR(44);
PRINTSCALED(MEM[H+6].INT);END;PRINTCHAR(125);GOTO 30;END{:267};P:=H;
REPEAT Q:=MEM[P].HH.RH;IF(P=0)OR(Q=0)THEN BEGIN PRINTNL(365);GOTO 30;
END;{268:}PRINTTWO(MEM[P+1].INT,MEM[P+2].INT);
IF MEM[P].HH.B1<=1 THEN{269:}
IF MEM[P].HH.B0=2 THEN BEGIN R:=MEM[P+3].INT;PRINTCHAR(123);
PRINTSCALED(MEM[R+1].INT);PRINTCHAR(44);PRINTSCALED(MEM[R+2].INT);
PRINTCHAR(125);END ELSE IF MEM[P].HH.B0=3 THEN BEGIN PRINT(368);
PRINTSCALED(MEM[P+3].INT);PRINTCHAR(125);END{:269};
CASE MEM[P].HH.B1 OF 0:BEGIN IF MEM[P].HH.B0=4 THEN PRINT(369);
IF(MEM[Q].HH.B0<>0)OR(Q<>H)THEN Q:=0;GOTO 31;END;1:{271:}
BEGIN PRINT(374);PRINTTWO(MEM[P+5].INT,MEM[P+6].INT);PRINT(373);
IF MEM[Q].HH.B0<>1 THEN PRINT(375)ELSE PRINTTWO(MEM[Q+3].INT,MEM[Q+4].
INT);GOTO 31;END{:271};4:{272:}
IF(MEM[P].HH.B0<>1)AND(MEM[P].HH.B0<>4)THEN PRINT(369){:272};3,2:{273:}
BEGIN IF MEM[P].HH.B0>=2 THEN IF MEM[P].HH.B0=4 THEN PRINT(375)ELSE IF(
MEM[P].HH.B0<>MEM[P].HH.B1)OR(MEM[P+3].INT<>MEM[P+5].INT)THEN BEGIN{269:
}IF MEM[P].HH.B0=2 THEN BEGIN R:=MEM[P+3].INT;PRINTCHAR(123);
PRINTSCALED(MEM[R+1].INT);PRINTCHAR(44);PRINTSCALED(MEM[R+2].INT);
PRINTCHAR(125);END ELSE IF MEM[P].HH.B0=3 THEN BEGIN PRINT(368);
PRINTSCALED(MEM[P+3].INT);PRINTCHAR(125);END{:269};PRINTCHAR(38);
PRINTTWO(MEM[P+1].INT,MEM[P+2].INT);END;
IF MEM[P].HH.B1=3 THEN BEGIN PRINT(368);PRINTSCALED(MEM[P+5].INT);
PRINTCHAR(125);END ELSE BEGIN R:=MEM[P+5].INT;PRINTCHAR(123);
PRINTSCALED(MEM[R+1].INT);PRINTCHAR(44);PRINTSCALED(MEM[R+2].INT);
PRINTCHAR(125);END;END{:273};OTHERS:PRINT(370)END;
IF MEM[Q].HH.B0<=1 THEN PRINT(371)ELSE IF(MEM[P+6].INT<>65536)OR(MEM[Q+4
].INT<>65536)THEN{270:}BEGIN PRINT(372);PRINTSCALED(MEM[P+6].INT);
IF MEM[P+6].INT<>MEM[Q+4].INT THEN BEGIN PRINT(373);
PRINTSCALED(MEM[Q+4].INT);END;END{:270};31:{:268};P:=Q;
IF P<>H THEN PRINTNL(366);UNTIL P=H;
IF MEM[H].HH.B0<>0 THEN PRINTNL(367);30:ENDDIAGNOSTI(TRUE);END;{:266}
{274:}PROCEDURE TOSSKNOTLIST(P:HALFWORD);VAR Q:HALFWORD;
BEGIN WHILE P<>0 DO BEGIN Q:=P;P:=MEM[Q].HH.RH;FREENODE(Q,7);END;END;
{:274}{275:}{302:}
FUNCTION CURLRATIO(GAMMA,ATENSION,BTENSION:SCALED):FRACTION;
VAR ALPHA,BETA,NUM,DENOM,FF:FRACTION;
BEGIN ALPHA:=MAKEFRACTION(65536,ATENSION);
BETA:=MAKEFRACTION(65536,BTENSION);
IF ALPHA<=BETA THEN BEGIN FF:=MAKEFRACTION(ALPHA,BETA);
FF:=TAKEFRACTION(FF,FF);GAMMA:=TAKEFRACTION(GAMMA,FF);
BETA:=BETA DIV 4096;DENOM:=TAKEFRACTION(GAMMA,ALPHA)+196608-BETA;
NUM:=TAKEFRACTION(GAMMA,805306368-ALPHA)+BETA;
END ELSE BEGIN FF:=MAKEFRACTION(BETA,ALPHA);FF:=TAKEFRACTION(FF,FF);
BETA:=TAKEFRACTION(BETA,FF)DIV 4096;
DENOM:=TAKEFRACTION(GAMMA,ALPHA)+(FF DIV 1365)-BETA;
NUM:=TAKEFRACTION(GAMMA,805306368-ALPHA)+BETA;END;
IF NUM>=DENOM+DENOM+DENOM+DENOM THEN CURLRATIO:=1073741824 ELSE
CURLRATIO:=MAKEFRACTION(NUM,DENOM);END;{:302}{305:}
PROCEDURE SETCONTROLS(P,Q:HALFWORD;K:INTEGER);VAR RR,SS:FRACTION;
BEGIN RR:=VELOCITY(ST,CT,SF,CF,MEM[P+6].INT);
SS:=VELOCITY(SF,CF,ST,CT,MEM[Q+4].INT);
MEM[P+5].INT:=MEM[P+1].INT+TAKEFRACTION(TAKEFRACTION(DELTAX[K],CT)-
TAKEFRACTION(DELTAY[K],ST),RR);
MEM[P+6].INT:=MEM[P+2].INT+TAKEFRACTION(TAKEFRACTION(DELTAY[K],CT)+
TAKEFRACTION(DELTAX[K],ST),RR);
MEM[Q+3].INT:=MEM[Q+1].INT-TAKEFRACTION(TAKEFRACTION(DELTAX[K],CF)+
TAKEFRACTION(DELTAY[K],SF),SS);
MEM[Q+6].INT:=MEM[Q+2].INT-TAKEFRACTION(TAKEFRACTION(DELTAY[K],CF)-
TAKEFRACTION(DELTAX[K],SF),SS);MEM[P].HH.B1:=1;MEM[Q].HH.B0:=1;END;
{:305}PROCEDURE MAKECHOICES(KNOTS,COORDS:HALFWORD);LABEL 30,31,40;
VAR H:HALFWORD;P,Q:HALFWORD;{286:}K,N:0..PATHSIZE;R,S,T:HALFWORD;
SINE,COSINE:FRACTION;{:286}{292:}AA,BB,CC,FF,ACC:FRACTION;DD,EE:SCALED;
{:292}BEGIN IF INTERNAL[3]>0 THEN PRINTPATH(KNOTS,376);
BEGIN IF ARITHERROR THEN CLEARARITH;END;{277:}P:=KNOTS;
REPEAT Q:=MEM[P].HH.RH;
IF MEM[P+1].INT=MEM[Q+1].INT THEN IF MEM[P+2].INT=MEM[Q+2].INT THEN IF
MEM[P].HH.B1>1 THEN BEGIN MEM[P].HH.B1:=1;
IF MEM[P].HH.B0=4 THEN BEGIN MEM[P].HH.B0:=3;MEM[P+3].INT:=65536;END;
MEM[Q].HH.B0:=1;IF MEM[Q].HH.B1=4 THEN BEGIN MEM[Q].HH.B1:=3;
MEM[P+5].INT:=65536;END;MEM[P+5].INT:=MEM[P+1].INT;
MEM[Q+3].INT:=MEM[P+1].INT;MEM[P+6].INT:=MEM[P+2].INT;
MEM[Q+4].INT:=MEM[P+2].INT;END;P:=Q;UNTIL P=KNOTS{:277};{278:}H:=KNOTS;
WHILE TRUE DO BEGIN IF MEM[H].HH.B0<>4 THEN GOTO 31;
IF MEM[H].HH.B1<>4 THEN GOTO 31;H:=MEM[H].HH.RH;
IF H=KNOTS THEN BEGIN MEM[H].HH.B0:=5;GOTO 31;END;END;31:{:278};P:=H;
REPEAT{279:}Q:=MEM[P].HH.RH;
IF MEM[P].HH.B1>=2 THEN BEGIN WHILE(MEM[Q].HH.B0=4)AND(MEM[Q].HH.B1=4)DO
Q:=MEM[Q].HH.RH;{284:}{287:}K:=0;S:=P;N:=PATHSIZE;
REPEAT T:=MEM[S].HH.RH;DELTAX[K]:=MEM[T+1].INT-MEM[S+1].INT;
DELTAY[K]:=MEM[T+2].INT-MEM[S+2].INT;
DELTA[K]:=PYTHADD(DELTAX[K],DELTAY[K]);
IF K>0 THEN BEGIN SINE:=MAKEFRACTION(DELTAY[K-1],DELTA[K-1]);
COSINE:=MAKEFRACTION(DELTAX[K-1],DELTA[K-1]);
PSI[K]:=MATAN(TAKEFRACTION(DELTAX[K],COSINE)+TAKEFRACTION(DELTAY[K],SINE
),TAKEFRACTION(DELTAY[K],COSINE)-TAKEFRACTION(DELTAX[K],SINE));END;
K:=K+1;S:=T;IF K=PATHSIZE THEN OVERFLOW(381,PATHSIZE);IF S=Q THEN N:=K;
UNTIL(K>=N)AND(MEM[S].HH.B0<>5);IF K=N THEN PSI[N]:=0{:287};{288:}
IF MEM[Q].HH.B0=4 THEN BEGIN MEM[17].INT:=MEM[Q+5].INT-MEM[Q+1].INT;
MEM[18].INT:=MEM[Q+6].INT-MEM[Q+2].INT;
IF(MEM[17].INT=0)AND(MEM[18].INT=0)THEN BEGIN MEM[Q].HH.B0:=3;
MEM[Q+3].INT:=65536;END ELSE BEGIN MEM[Q].HH.B0:=2;MEM[Q+3].INT:=16;END;
IF(MEM[P].HH.B1=4)AND(MEM[P].HH.B0=1)THEN BEGIN MEM[15].INT:=MEM[Q+1].
INT-MEM[Q+3].INT;MEM[16].INT:=MEM[Q+2].INT-MEM[Q+4].INT;
IF(MEM[15].INT=0)AND(MEM[16].INT=0)THEN BEGIN MEM[Q].HH.B1:=3;
MEM[Q+5].INT:=65536;END ELSE BEGIN MEM[Q].HH.B1:=2;MEM[Q+5].INT:=14;
END{:288};{290:}K:=0;S:=P;WHILE TRUE DO BEGIN T:=MEM[S].HH.RH;
IF K=0 THEN{291:}CASE MEM[S].HH.B1 OF 2:IF MEM[T].HH.B0=2 THEN{306:}
BEGIN COSINE:=MAKEFRACTION(DELTAX[0],DELTA[0]);
SINE:=MAKEFRACTION(DELTAY[0],DELTA[0]);R:=MEM[P+5].INT;
CT:=TAKEFRACTION(MEM[R+1].INT,COSINE)+TAKEFRACTION(MEM[R+2].INT,SINE);
ST:=TAKEFRACTION(MEM[R+2].INT,COSINE)-TAKEFRACTION(MEM[R+1].INT,SINE);
AA:=PYTHADD(ST,CT);CT:=TAKEFRACTION(CT,AA);ST:=TAKEFRACTION(ST,AA);
R:=MEM[Q+3].INT;
CF:=TAKEFRACTION(MEM[R+1].INT,COSINE)+TAKEFRACTION(MEM[R+2].INT,SINE);
SF:=-TAKEFRACTION(MEM[R+2].INT,COSINE)+TAKEFRACTION(MEM[R+1].INT,SINE);
AA:=PYTHADD(SF,CF);CF:=TAKEFRACTION(CF,AA);SF:=TAKEFRACTION(SF,AA);
SETCONTROLS(P,Q,0);GOTO 30;END{:306}ELSE{299:}BEGIN R:=MEM[S+5].INT;
SINE:=MAKEFRACTION(DELTAY[0],DELTA[0]);
COSINE:=MAKEFRACTION(DELTAX[0],DELTA[0]);
VV[0]:=NATAN(TAKEFRACTION(MEM[R+1].INT,COSINE)+TAKEFRACTION(MEM[R+2].INT
,SINE),TAKEFRACTION(Y,COORD(R),COSINE)-TAKEFRACTION(MEM[R+1].INT,SINE));
UU[0]:=0;WW[0]:=0;END{:299};3:IF MEM[T].HH.B0=3 THEN{307:}
BEGIN MEM[P].HH.B1:=1;MEM[Q].HH.B0:=1;
IF MEM[P+6].INT=65536 THEN BEGIN MEM[P+5].INT:=MEM[P+1].INT+((DELTAX[0]
+1)DIV 3);MEM[P+6].INT:=MEM[P+2].INT+((DELTAY[0]+1)DIV 3);
END ELSE BEGIN FF:=MAKEFRACTION(65536,3*MEM[P+6].INT);
MEM[P+5].INT:=MEM[P+1].INT+TAKEFRACTION(DELTAX[0],FF);
MEM[P+6].INT:=MEM[P+2].INT+TAKEFRACTION(DELTAY[0],FF);END;
IF MEM[Q+4].INT=65536 THEN BEGIN MEM[Q+3].INT:=MEM[Q+1].INT-((DELTAX[0]
+1)DIV 3);MEM[Q+4].INT:=MEM[Q+2].INT-((DELTAY[0]+1)DIV 3);
END ELSE BEGIN FF:=MAKEFRACTION(65536,3*MEM[Q+4].INT);
MEM[Q+3].INT:=MEM[Q+1].INT-TAKEFRACTION(DELTAX[0],FF);
MEM[Q+4].INT:=MEM[Q+2].INT-TAKEFRACTION(DELTAY[0],FF);END;GOTO 30;
END{:307}ELSE{300:}BEGIN CC:=MEM[S+5].INT;
IF(MEM[S+6].INT=65536)AND(MEM[T+4].INT=65536)THEN UU[0]:=MAKEFRACTION(CC
+CC+65536,CC+131072)ELSE UU[0]:=CURLRATIO(CC,MEM[S+6].INT,MEM[T+4].INT);
VV[0]:=-TAKEFRACTION(PSI[1],UU[0]);WW[0]:=0;END{:300};4:BEGIN UU[0]:=0;
VV[0]:=0;WW[0]:=268435456;END;END{:291}
ELSE CASE MEM[S].HH.B0 OF 5,4:{293:}BEGIN{294:}
IF MEM[R+6].INT=65536 THEN BEGIN AA:=134217728;DD:=2*DELTA[K];
END ELSE BEGIN AA:=MAKEFRACTION(65536,3*MEM[R+6].INT-65536);
DD:=TAKEFRACTION(DELTA[K],805306368-MAKEFRACTION(65536,MEM[R+6].INT));
END;IF MEM[T+4].INT=65536 THEN BEGIN BB:=134217728;EE:=2*DELTA[K-1];
END ELSE BEGIN BB:=MAKEFRACTION(65536,3*MEM[T+4].INT-65536);
EE:=TAKEFRACTION(DELTA[K-1],805306368-MAKEFRACTION(65536,MEM[T+4].INT));
END;CC:=268435456-TAKEFRACTION(UU[K-1],AA){:294};{295:}
DD:=TAKEFRACTION(DD,CC);
IF MEM[S+4].INT<>MEM[S+6].INT THEN IF MEM[S+4].INT<MEM[S+6].INT THEN
BEGIN FF:=MAKEFRACTION(MEM[S+4].INT,MEM[S+6].INT);
FF:=TAKEFRACTION(FF,FF);DD:=TAKEFRACTION(DD,FF);
END ELSE BEGIN FF:=MAKEFRACTION(MEM[S+6].INT,MEM[S+4].INT);
FF:=TAKEFRACTION(FF,FF);EE:=TAKEFRACTION(EE,FF);END;
FF:=MAKEFRACTION(EE,EE+DD){:295};UU[K]:=TAKEFRACTION(FF,BB);{296:}
ACC:=-TAKEFRACTION(PSI[K+1],UU[K]);
IF MEM[R].HH.B1=3 THEN BEGIN WW[K]:=0;
VV[K]:=ACC-TAKEFRACTION(PSI[1],268435456-FF);
END ELSE BEGIN FF:=MAKEFRACTION(268435456-FF,CC);
ACC:=ACC-TAKEFRACTION(PSI[K],FF);FF:=TAKEFRACTION(FF,AA);
VV[K]:=ACC-TAKEFRACTION(VV[K-1],FF);
IF WW[K-1]=0 THEN WW[K]:=0 ELSE WW[K]:=-TAKEFRACTION(WW[K-1],FF);
END{:296};IF MEM[S].HH.B0=5 THEN{297:}BEGIN AA:=0;BB:=268435456;
REPEAT K:=K-1;IF K=0 THEN K:=N;AA:=VV[K]-TAKEFRACTION(AA,UU[K]);
BB:=WW[K]-TAKEFRACTION(BB,UU[K]);UNTIL K=N;
AA:=MAKEFRACTION(AA,268435456-BB);THETA[N]:=AA;VV[0]:=AA;
FOR K:=1 TO N-1 DO VV[K]:=VV[K]+TAKEFRACTION(AA,WW[K]);GOTO 40;END{:297}
;END{:293};3:{301:}BEGIN CC:=MEM[S+3].INT;
IF(MEM[R+6].INT=65536)AND(MEM[S+4].INT=65536)THEN FF:=MAKEFRACTION(CC+CC
+65536,CC+131072)ELSE FF:=CURLRATIO(CC,MEM[S+4].INT,MEM[R+6].INT);
THETA[N]:=-MAKEFRACTION(TAKEFRACTION(VV[N-1],FF),268435456-TAKEFRACTION(
FF,UU[N-1]));GOTO 40;END{:301};2:{298:}BEGIN R:=MEM[S+3].INT;
SINE:=MAKEFRACTION(DELTAY[N-1],DELTA[N-1]);
COSINE:=MAKEFRACTION(DELTAX[N-1],DELTA[N-1]);
THETA[N]:=NATAN(TAKEFRACTION(MEM[R+1].INT,COSINE)+TAKEFRACTION(MEM[R+2].
INT,SINE),TAKEFRACTION(MEM[R+2].INT,COSINE)-TAKEFRACTION(MEM[R+1].INT,
SINE));GOTO 40;END{:298};END;R:=S;S:=T;K:=K+1;END;40:{303:}
FOR K:=N-1 DOWNTO 0 DO THETA[K]:=VV[K]-TAKEFRACTION(THETA[K+1],UU[K]);
S:=P;K:=0;REPEAT T:=MEM[S].HH.RH;NSINCOS(THETA[K]);ST:=NSIN;CT:=NCOS;
NSINCOS(-PSI[K+1]-THETA[K+1]);SF:=NSIN;CF:=NCOS;SETCONTROLS(S,T,K);
K:=K+1;S:=T;UNTIL K=N{:303};30:{:290}{:284};END;P:=Q{:279};UNTIL P=H;
IF INTERNAL[3]>0 THEN PRINTPATH(KNOTS,377);
WHILE COORDS<>0 DO BEGIN P:=COORDS;COORDS:=MEM[P].HH.RH;FREENODE(P,3);
END;IF ARITHERROR THEN{276:}BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(378);END;BEGIN HELPPTR:=2;HELPLINE[1]:=379;
HELPLINE[0]:=380;END;ERROR;END{:276};END;{:275}{316:}
PROCEDURE MAKEMOVES(XX0,XX1,XX2,XX3,YY0,YY1,YY2,YY3:SCALED);
LABEL 22,30,10;VAR X1,X2,X3,M,R,Y1,Y2,Y3,N,S,L:INTEGER;
Q,T,U,X2A,X3A,Y2A,Y3A:INTEGER;BEGIN L:=16;BISECTPTR:=0;X1:=XX1-XX0;
X2:=XX2-XX1;X3:=XX3-XX2;
IF XX0>=0 THEN R:=XX0 MOD 65536 ELSE R:=65535-((-XX0-1)MOD 65536);
M:=(XX3-XX0+R)DIV 65536;Y1:=YY1-YY0;Y2:=YY2-YY1;Y3:=YY3-YY2;
IF YY0>=0 THEN S:=YY0 MOD 65536 ELSE S:=65535-((-YY0-1)MOD 65536);
N:=(YY3-YY0+S)DIV 65536;WHILE TRUE DO BEGIN 22:{318:}IF M=0 THEN{319:}
WHILE N>0 DO BEGIN MOVEPTR:=MOVEPTR+1;MOVE[MOVEPTR]:=1;N:=N-1;END{:319}
ELSE IF N=0 THEN{320:}MOVE[MOVEPTR]:=MOVE[MOVEPTR]+M{:320}
ELSE IF M+N=2 THEN{321:}R:=TWOTOTHE[L]-R;S:=TWOTOTHE[L]-S;
WHILE L<30 DO BEGIN X3A:=X3;X2A:=(X2+X3)DIV 2;X2:=(X1+X2)DIV 2;
X3:=(X2+X2A)DIV 2;T:=X1+X2+X3;R:=R+R;Y3A:=Y3;Y2A:=(Y2+Y3)DIV 2;
Y2:=(Y1+Y2)DIV 2;Y3:=(Y2+Y2A)DIV 2;U:=Y1+Y2+Y3;S:=S+S;
IF T<R THEN IF U<S THEN{322:}BEGIN X3:=X3A;X2:=X2A;X1:=X3;R:=R-T;
Y3:=Y3A;Y2:=Y2A;Y1:=Y3;S:=S-U;END{:322}ELSE BEGIN{324:}
BEGIN MOVEPTR:=MOVEPTR+1;MOVE[MOVEPTR]:=2;END{:324};GOTO 30;
END ELSE IF U<S THEN BEGIN{323:}BEGIN MOVE[MOVEPTR]:=MOVE[MOVEPTR]+1;
MOVEPTR:=MOVEPTR+1;MOVE[MOVEPTR]:=1;END{:323};GOTO 30;END;L:=L+1;END;
30:IF ABGEQCD(T-R,S,U-S,R)THEN{323:}
BEGIN MOVE[MOVEPTR]:=MOVE[MOVEPTR]+1;MOVEPTR:=MOVEPTR+1;
MOVE[MOVEPTR]:=1;END{:323}ELSE{324:}BEGIN MOVEPTR:=MOVEPTR+1;
MOVE[MOVEPTR]:=2;END{:324}{:321}ELSE BEGIN L:=L+1;
BISECTSTACK[BISECTPTR+10]:=L;BISECTSTACK[BISECTPTR+2]:=X3;
BISECTSTACK[BISECTPTR+1]:=(X2+X3)DIV 2;X2:=(X1+X2)DIV 2;
X3:=(X2,BISECTSTACK[BISECTPTR+1])DIV 2;BISECTSTACK[BISECTPTR]:=X3;
R:=R+R;T:=X1+X2+X3+R;Q:=T DIV TWOTOTHE[L];
BISECTSTACK[BISECTPTR+3]:=T MOD TWOTOTHE[L];
BISECTSTACK[BISECTPTR+4]:=M-Q;M:=Q;BISECTSTACK[BISECTPTR+7]:=Y3;
BISECTSTACK[BISECTPTR+6]:=(Y2+Y3)DIV 2;Y2:=(Y1+Y2)DIV 2;
Y3:=(Y2,BISECTSTACK[BISECTPTR+6])DIV 2;BISECTSTACK[BISECTPTR+5]:=Y3;
S:=S+S;U:=Y1+Y2+Y3+S;Q:=U DIV TWOTOTHE[L];
BISECTSTACK[BISECTPTR+8]:=U MOD TWOTOTHE[L];
BISECTSTACK[BISECTPTR+9]:=N-Q;N:=Q;BISECTPTR:=BISECTPTR+11;GOTO 22;
END{:318};IF BISECTPTR=0 THEN GOTO 10;{317:}BISECTPTR:=BISECTPTR-11;
X1:=BISECTSTACK[BISECTPTR];X2:=BISECTSTACK[BISECTPTR+1];
X3:=BISECTSTACK[BISECTPTR+2];R:=BISECTSTACK[BISECTPTR+3];
M:=BISECTSTACK[BISECTPTR+4];Y1:=BISECTSTACK[BISECTPTR+5];
Y2:=BISECTSTACK[BISECTPTR+6];Y3:=BISECTSTACK[BISECTPTR+7];
S:=BISECTSTACK[BISECTPTR+8];N:=BISECTSTACK[BISECTPTR+9];
L:=BISECTSTACK[BISECTPTR+10]{:317};END;10:END;{:316}{329:}
PROCEDURE NEWEDGES:HALFWORD;VAR H:HALFWORD;BEGIN H:=GETNODE(6);
MEM[H].HH.LH:=H;MEM[H].HH.RH:=H;MEM[H+1].HH.LH:=8191;MEM[H+1].HH.RH:=1;
MEM[H+2].HH.LH:=8191;MEM[H+2].HH.RH:=1;MEM[H+3].HH.LH:=4096;
MEM[H+3].HH.RH:=0;MEM[H+4].INT:=0;MEM[H+5].HH.RH:=H;
MEM[H+5].HH.LH:=MEM[H+1].HH.RH+1;NEWEDGES:=H;END;{:329}{331:}
PROCEDURE EDGEPREP(ML,MR,NL,NR:INTEGER);VAR DELTA:HALFWORD;P,Q:HALFWORD;
BEGIN ML:=ML+4096;MR:=MR+4096;NL:=NL+4096;NR:=NR+4096;
IF ML<MEM[CUREDGES+2].HH.LH THEN MEM[CUREDGES+2].HH.LH:=ML;
IF MR<MEM[CUREDGES+2].HH.RH THEN MEM[CUREDGES+2].HH.RH:=MR;
IF(ABS(MEM[CUREDGES+2].HH.LH-MEM[CUREDGES+3].HH.LH)>=4096)OR(ABS(MEM[
CUREDGES+2].HH.RH-MEM[CUREDGES+3].HH.LH)>=4096)THEN{334:}
BEGIN DELTA:=8*(MEM[CUREDGES+3].HH.LH-4096);MEM[CUREDGES+3].HH.LH:=4096;
Q:=MEM[CUREDGES].HH.RH;WHILE Q<>CUREDGES DO BEGIN P:=MEM[Q+1].HH.RH;
WHILE P>13000 DO BEGIN MEM[P].HH.LH:=MEM[P].HH.LH-DELTA;P:=MEM[P].HH.RH;
END;P:=MEM[Q+1].HH.LH;
WHILE P>1 DO BEGIN MEM[P].HH.LH:=MEM[P].HH.LH-DELTA;P:=MEM[P].HH.RH;END;
Q:=MEM[Q].HH.RH;END;END{:334};
IF MEM[CUREDGES].HH.RH=CUREDGES THEN BEGIN MEM[CUREDGES+1].HH.LH:=NR+1;
MEM[CUREDGES+1].HH.RH:=NR;MEM[CUREDGES+5].HH.LH:=NR+1;END;
IF NL<MEM[CUREDGES+1].HH.LH THEN{332:}
BEGIN DELTA:=MEM[CUREDGES+1].HH.LH-NL;MEM[CUREDGES+1].HH.LH:=NL;
P:=MEM[CUREDGES].HH.RH;REPEAT Q:=GETNODE(2);MEM[Q+1].HH.RH:=13000;
MEM[Q+1].HH.LH:=1;MEM[P].HH.LH:=Q;MEM[Q].HH.RH:=P;P:=Q;DELTA:=DELTA-1;
UNTIL DELTA=0;MEM[P].HH.LH:=CUREDGES;MEM[CUREDGES].HH.RH:=P;END{:332};
IF NR>MEM[CUREDGES+1].HH.RH THEN{333:}
BEGIN DELTA:=NR-MEM[CUREDGES+1].HH.RH;MEM[CUREDGES+1].HH.RH:=NR;
P:=MEM[CUREDGES].HH.LH;REPEAT Q:=GETNODE(2);MEM[Q+1].HH.RH:=13000;
MEM[Q+1].HH.LH:=1;MEM[P].HH.RH:=Q;MEM[Q].HH.LH:=P;P:=Q;DELTA:=DELTA-1;
UNTIL DELTA=0;MEM[P].HH.RH:=CUREDGES;MEM[CUREDGES].HH.LH:=P;END{:333};
END;{:331}{335:}{336:}PROCEDURE PRINTWEIGHT(Q:HALFWORD);VAR W,M:INTEGER;
Z:INTEGER;BEGIN Z:=Q-0;W:=Z MOD 8;M:=(Z DIV 8)-MEM[CUREDGES+3].HH.LH;
IF FILEOFFSET>MAXPRINTLINE-9 THEN PRINTNL(32)ELSE PRINTCHAR(32);
PRINTINT(M);WHILE W>4 DO BEGIN PRINTCHAR(43);W:=W-1;END;
WHILE W<4 DO BEGIN PRINTCHAR(45);W:=W+1;END;END;{:336}
PROCEDURE PRINTEDGES(H:HALFWORD;S:STRNUMBER);VAR P,Q:HALFWORD;N:INTEGER;
BEGIN PRINTDIAGNOS(382,S);P:=MEM[H].HH.LH;N:=MEM[H+1].HH.RH-4096;
CUREDGES:=H;WHILE P<>H DO BEGIN PRINTNL(383);PRINTINT(N);PRINTCHAR(58);
Q:=MEM[P+1].HH.LH;WHILE Q>1 DO BEGIN PRINTWEIGHT(Q);Q:=MEM[Q].HH.RH;END;
PRINT(384);Q:=MEM[P+1].HH.RH;WHILE Q>13000 DO BEGIN PRINTWEIGHT(Q);
Q:=MEM[Q].HH.RH;END;P:=MEM[P].HH.LH;N:=N-1;END;ENDDIAGNOSTI(TRUE);END;
{:335}{337:}FUNCTION COPYEDGES(H:HALFWORD):HALFWORD;VAR P,R:HALFWORD;
HH,PP,QQ,RR,SS:HALFWORD;BEGIN HH:=GETNODE(6);MEM[HH+1]:=MEM[H+1];
MEM[HH+2]:=MEM[H+2];MEM[HH+3]:=MEM[H+3];MEM[HH+4]:=MEM[H+4];
MEM[HH+5].HH.LH:=MEM[HH+1].HH.RH+1;MEM[HH+5].HH.RH:=HH;P:=MEM[H].HH.RH;
QQ:=HH;WHILE P<>H DO BEGIN PP:=GETNODE(ROWHEADERSIZ);MEM[QQ].HH.RH:=PP;
MEM[PP].HH.LH:=QQ;{338:}R:=MEM[P+1].HH.RH;RR:=PP+1;
WHILE R>13000 DO BEGIN SS:=GETAVAIL;MEM[RR].HH.RH:=SS;RR:=SS;
MEM[RR].HH.LH:=MEM[R].HH.LH;R:=MEM[R].HH.RH;END;MEM[RR].HH.RH:=13000;
R:=MEM[P+1].HH.LH;RR:=13001;WHILE R>1 DO BEGIN SS:=GETAVAIL;
MEM[RR].HH.RH:=SS;RR:=SS;MEM[RR].HH.LH:=MEM[R].HH.LH;R:=MEM[R].HH.RH;
END;MEM[RR].HH.RH:=R;MEM[PP+1].HH.LH:=MEM[13001].HH.RH{:338};
P:=MEM[P].HH.RH;QQ:=PP;END;MEM[QQ].HH.RH:=HH;MEM[HH].HH.LH:=QQ;
COPYEDGES:=HH;END;{:337}{339:}PROCEDURE SORTEDGES(H:HALFWORD);LABEL 30;
VAR K:HALFWORD;P,Q,R,S:HALFWORD;BEGIN R:=MEM[H+1].HH.LH;
MEM[H+1].HH.LH:=0;P:=MEM[R].HH.RH;MEM[R].HH.RH:=13000;
MEM[13001].HH.RH:=R;WHILE P<=1 DO BEGIN K:=MEM[P].HH.LH;Q:=13001;
REPEAT R:=Q;Q:=MEM[R].HH.RH;UNTIL K<=MEM[Q].HH.LH;MEM[R].HH.RH:=P;
R:=MEM[P].HH.RH;MEM[P].HH.RH:=Q;P:=R;END;{340:}BEGIN R:=H+1;
Q:=MEM[R].HH.RH;P:=MEM[13001].HH.RH;WHILE TRUE DO BEGIN K:=MEM[P].HH.LH;
WHILE K>MEM[Q].HH.LH DO BEGIN R:=Q;Q:=MEM[R].HH.RH;END;MEM[R].HH.RH:=P;
S:=MEM[R].HH.RH;MEM[P].HH.RH:=Q;IF S=13000 THEN GOTO 30;R:=P;P:=S;END;
30:{:340};END;{:339}{341:}PROCEDURE CULLEDGES(H:HALFWORD;
WPLUS,WMINUS:INTEGER);VAR P,Q,R,S:HALFWORD;W:INTEGER;Z:INTEGER;
M:INTEGER;WW:INTEGER;PREVM,PREVWW:INTEGER;BEGIN P:=MEM[H].HH.RH;
WHILE P<>H DO BEGIN IF MEM[P+1].HH.LH>1 THEN SORTEDGES(P);{342:}W:=0;
R:=13001;PREVM:=-1;PREVWW:=0;Q:=MEM[P+1].HH.RH;
WHILE Q>13000 DO BEGIN Z:=MEM[Q].HH.LH-0;M:=Z DIV 8;W:=W+(Z MOD 8)-4;
IF M<>PREVM THEN{343:}
BEGIN IF(W>=WPLUS)OR(W<=WMINUS)THEN WW:=1 ELSE WW:=0;
IF WW<>PREVWW THEN BEGIN S:=GETAVAIL;MEM[R].HH.RH:=S;
MEM[S].HH.LH:=8*M+4+WW-PREVWW;R:=S;PREVWW:=WW;END;PREVM:=M;END{:343};
S:=MEM[Q].HH.RH;BEGIN MEM[Q].HH.RH:=AVAIL;AVAIL:=Q;{DYNUSED:=DYNUSED-1;}
END;Q:=S;END;MEM[R].HH.RH:=13000;MEM[P+1].HH.RH:=MEM[13001].HH.RH{:342}
P:=MEM[P].HH.RH;END;END;{:341}{344:}
PROCEDURE LINEEDGES(X0,Y0,X1,Y1:SCALED);LABEL 30,31;
VAR M0,N0,M1,N1,N:INTEGER;DELX,DELY:SCALED;YT:SCALED;
P,BEGIN N0:=ROUNDUNSCALE(Y0);N1:=ROUNDUNSCALE(Y1);
IF N0<>N1 THEN BEGIN M0:=ROUNDUNSCALE(X0);M1:=ROUNDUNSCALE(X1);
DELX:=X1-X0;DELY:=Y1-Y0;YT:=N0*65536-32768;Y0:=Y0-YT;Y1:=Y1-YT;
IF N0<N1 THEN{345:}BEGIN N1:=N1-1;BASE:=8*MEM[CUREDGES+3].HH.LH+4-CURWT;
IF M0<=M1 THEN EDGEPREP(M0,M1,N0,N1)ELSE EDGEPREP(M1,M0,N0,N1);{347:}
N:=MEM[CUREDGES+5].HH.LH-4096;P:=MEM[CUREDGES+5].HH.RH;
IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
Y0:=65535-Y0;WHILE TRUE DO BEGIN R:=GETAVAIL;
MEM[R].HH.RH:=MEM[P+1].HH.LH;MEM[P+1].HH.LH:=R;
MEM[R].HH.LH:=8*ROUNDUNSCALE(X0+TAKEFRACTION(DELX,MAKEFRACTION(Y0,DELY))
)+BASE;Y1:=Y1-65536;IF Y1<65536 THEN GOTO 30;P:=MEM[P].HH.RH;
Y0:=Y0+65536;END;30:END{:345}ELSE{346:}BEGIN N0:=N0-1;
BASE:=8*MEM[CUREDGES+3].HH.LH+4+CURWT;
IF M0<=M1 THEN EDGEPREP(M0,M1,N0,N1)ELSE EDGEPREP(M1,M0,N0,N1);{347:}
N:=MEM[CUREDGES+5].HH.LH-4096;P:=MEM[CUREDGES+5].HH.RH;
IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
WHILE TRUE DO BEGIN R:=GETAVAIL;MEM[R].HH.RH:=MEM[P+1].HH.LH;
MEM[P+1].HH.LH:=R;
MEM[R].HH.LH:=8*ROUNDUNSCALE(X0-TAKEFRACTION(DELX,MAKEFRACTION(Y0,DELY))
)+BASE;Y1:=Y1+65536;IF Y1>=0 THEN GOTO 31;P:=MEM[P].HH.LH;Y0:=Y0+65536;
END;31:END{:346};MEM[CUREDGES+5].HH.RH:=P;
MEM[CUREDGES+5].HH.LH:=N1+4096;END;END;{:344}{348:}
PROCEDURE MOVETOEDGES(M0,N0,M1,N1:INTEGER;OCTANT:SMALLNUMBER);
LABEL 60,61,62,63,30;VAR DELTA:0..MOVESIZE;K:0..MOVESIZE;P,R:HALFWORD;
DX:INTEGER;EDGEANDWEIGH:INTEGER;N:INTEGER;NFIN:INTEGER;
BEGIN DELTA:=N1-N0;CASE OCTANT OF 1:BEGIN DX:=8;GOTO 60;END;
5:BEGIN DX:=8;GOTO 62;END;6:BEGIN DX:=-8;N0:=-N0;GOTO 62;END;
2:BEGIN DX:=-8;M0:=-M0;GOTO 60;END;4:BEGIN DX:=-8;M0:=-M0;GOTO 61;END;
8:BEGIN DX:=-8;N0:=-N0;GOTO 63;END;7:BEGIN DX:=8;GOTO 63;END;
3:BEGIN DX:=8;GOTO 61;END;END;60:{349:}
IF DX>0 THEN EDGEPREP(M0,M1,N0,N1-1)ELSE EDGEPREP(-M1,M0,N0,N1-1);
NFIN:=N1;{347:}N:=MEM[CUREDGES+5].HH.LH-4096;P:=MEM[CUREDGES+5].HH.RH;
IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
IF DELTA>0 THEN BEGIN K:=0;
EDGEANDWEIGH:=8*(M0+MEM[CUREDGES+3].HH.LH)+HALFWORD+4-CURWT;
REPEAT EDGEANDWEIGH:=EDGEANDWEIGH+DX*MOVE[K];BEGIN R:=AVAIL;
IF R=0 THEN R:=GETAVAIL ELSE BEGIN AVAIL:=MEM[R].HH.RH;MEM[R].HH.RH:=0;
{DYNUSED:=DYNUSED+1;}END;END;MEM[R].HH.RH:=MEM[P+1].HH.LH;
MEM[R].HH.LH:=EDGEANDWEIGH;MEM[P+1].HH.LH:=R;P:=MEM[P].HH.RH;K:=K+1;
UNTIL K=DELTA;END;GOTO 30{:349};61:{350:}N0:=-N0-1;
IF DX>0 THEN EDGEPREP(M0,M1,-N1,N0)ELSE EDGEPREP(-M1,M0,-N1,N0);
NFIN:=-N1-1;{347:}N:=MEM[CUREDGES+5].HH.LH-4096;
P:=MEM[CUREDGES+5].HH.RH;IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
IF DELTA>0 THEN BEGIN K:=0;
EDGEANDWEIGH:=8*(M0+MEM[CUREDGES+3].HH.LH)+HALFWORD+4+CURWT;
REPEAT EDGEANDWEIGH:=EDGEANDWEIGH+DX*MOVE[K];BEGIN R:=AVAIL;
IF R=0 THEN R:=GETAVAIL ELSE BEGIN AVAIL:=MEM[R].HH.RH;MEM[R].HH.RH:=0;
{DYNUSED:=DYNUSED+1;}END;END;MEM[R].HH.RH:=MEM[P+1].HH.LH;
MEM[R].HH.LH:=EDGEANDWEIGH;MEM[P+1].HH.LH:=R;P:=MEM[P].HH.LH;K:=K+1;
UNTIL K=DELTA;END;GOTO 30{:350};62:{351:}
EDGEANDWEIGH:=8*(N0+MEM[CUREDGES+3].HH.LH)+HALFWORD+4-CURWT;
IF DX>0 THEN EDGEPREP(N0,N1,M0,M1-1)ELSE EDGEPREP(-N1,N0,M0,M1-1);
N0:=M0;NFIN:=M1;K:=0;{347:}N:=MEM[CUREDGES+5].HH.LH-4096;
P:=MEM[CUREDGES+5].HH.RH;IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
REPEAT N:=MOVES[K];WHILE N>0 DO BEGIN BEGIN R:=AVAIL;
IF R=0 THEN R:=GETAVAIL ELSE BEGIN AVAIL:=MEM[R].HH.RH;MEM[R].HH.RH:=0;
{DYNUSED:=DYNUSED+1;}END;END;MEM[R].HH.RH:=MEM[P+1].HH.LH;
MEM[R].HH.LH:=EDGEANDWEIGH;MEM[P+1].HH.LH:=R;P:=MEM[P].HH.RH;N:=N-1;END;
EDGEANDWEIGH:=EDGEANDWEIGH+DX;K:=K+1;UNTIL K>DELTA;GOTO 30{:351};
63:{352:}EDGEANDWEIGH:=8*(N0+MEM[CUREDGES+3].HH.LH)+HALFWORD+4+CURWT;
IF DX>0 THEN EDGEPREP(N0,N1,-M1,-M0-1)ELSE EDGEPREP(-N1,N0,-M1,-M0-1);
N0:=-M0-1;NFIN:=-M1-1;K:=0;{347:}N:=MEM[CUREDGES+5].HH.LH-4096;
P:=MEM[CUREDGES+5].HH.RH;IF N<N0 THEN REPEAT N:=N+1;P:=MEM[P].HH.RH;
UNTIL N=N0 ELSE REPEAT N:=N-1;P:=MEM[P].HH.LH;UNTIL N=N0{:347};
REPEAT N:=MOVES[K];WHILE N>0 DO BEGIN BEGIN R:=AVAIL;
IF R=0 THEN R:=GETAVAIL ELSE BEGIN AVAIL:=MEM[R].HH.RH;MEM[R].HH.RH:=0;
{DYNUSED:=DYNUSED+1;}END;END;MEM[R].HH.RH:=MEM[P+1].HH.LH;
MEM[R].HH.LH:=EDGEANDWEIGH;MEM[P+1].HH.LH:=R;P:=MEM[P].HH.RH;N:=N-1;END;
EDGEANDWEIGH:=EDGEANDWEIGH+DX;K:=K+1;UNTIL K>DELTA;GOTO 30{:352};
30:MEM[CUREDGES+5].HH.LH:=NFIN+4096;MEM[CUREDGES+5].HH.RH:=P;END;{:348}
{353:}FUNCTION TOSSEDGES(H:HALFWORD):BOOLEAN;VAR P,Q:HALFWORD;
DATALOST:BOOLEAN;BEGIN Q:=MEM[H].HH.RH;DATALOST:=FALSE;
WHILE Q<>H DO BEGIN FLUSHLIST(MEM[Q+1].HH.RH);
IF MEM[Q+1].HH.LH>1 THEN BEGIN DATALOST:=TRUE;FLUSHLIST(MEM[Q+1].HH.LH);
END;P:=Q;Q:=MEM[Q].HH.RH;FREENODE(P,2);END;FREENODE(H,6);
TOSSEDGES:=DATALOST;END;{:353}{355:}PROCEDURE ROTATE(X,Y:SCALED;
OCTANT:SMALLNUMBER);BEGIN CASE OCTANT OF 1:BEGIN CURX:=X;CURY:=Y;END;
5:BEGIN CURX:=Y;CURY:=X;END;6:BEGIN CURX:=Y;CURY:=-X-1;END;
2:BEGIN CURX:=-X-1;CURY:=Y;END;4:BEGIN CURX:=-X-1;CURY:=-Y-1;END;
8:BEGIN CURX:=-Y-1;CURY:=-X-1;END;7:BEGIN CURX:=-Y-1;CURY:=X;END;
3:BEGIN CURX:=X;CURY:=-Y-1;END;END;END;{:355}{356:}
PROCEDURE UNROTATE(X,Y:SCALED;OCTANT:SMALLNUMBER);{:356}{358:}
FUNCTION CROSSINGPOIN(A,B,C:INTEGER):FRACTION;LABEL 10;VAR D:INTEGER;
X,XX,X0,X1,X2:INTEGER;BEGIN IF A<0 THEN BEGIN CROSSINGPOIN:=0;GOTO 10;
END;IF C>=0 THEN BEGIN IF B>=0 THEN BEGIN CROSSINGPOIN:=268435457;
GOTO 10;END;IF A=0 THEN BEGIN CROSSINGPOIN:=0;GOTO 10;END;
END ELSE IF A=0 THEN IF B<=0 THEN BEGIN CROSSINGPOIN:=0;GOTO 10;END;
{359:}D:=1;X0:=A;X1:=A-B;X2:=B-C;REPEAT X0:=X0+X0;X:=(X1+X2)DIV 2;
IF X1>X0 THEN BEGIN X2:=X;D:=D+D;END ELSE BEGIN XX:=X1+X;
IF XX>X0 THEN BEGIN X2:=X;D:=D+D;END ELSE BEGIN X0:=X0-XX;
IF X<=X0 THEN IF X+X2<=X0 THEN BEGIN CROSSINGPOIN:=268435457;GOTO 10;
END;X1:=X;D:=D+D+1;END;END;UNTIL D>=268435456;
CROSSINGPOIN:=D-268435456{:359};10:END;{:358}{361:}
PROCEDURE PRINTSPEC(H:HALFWORD,S:STRNUMBER);VAR P,Q:HALFWORD;
OCTANT:SMALLNUMBER;BEGIN PRINTDIAGNOS(385,S);P:=H;PRINTLN;
PRINTTWO(MEM[H+1].INT,MEM[H+2].INT);PRINT(386);REPEAT Q:=MEM[P].HH.RH;
{362:}IF MEM[P].HH.B1<>0 THEN{363:}BEGIN PRINTNL(374);
UNROTATE(MEM[P+5].INT,MEM[P+6].INT,OCTANT);PRINTTWO(CURX,CURY);
PRINT(373);UNROTATE(MEM[Q+3].INT,MEM[Q+4].INT,OCTANT);
PRINTTWO(CURX,CURY);PRINT(398);
UNROTATE(MEM[Q+1].INT,MEM[Q+2].INT,OCTANT);PRINTTWO(CURX,CURY);
PRINT(399);PRINTINT(MEM[Q].HH.B0);PRINTCHAR(91);PRINT(MEM[P].HH.B1);
PRINTCHAR(93);END{:363}ELSE BEGIN PRINTNL(388);OCTANT:=MEM[Q+3].INT;
CASE OCTANT OF 1:PRINT(389);5:PRINT(390);6:PRINT(391);2:PRINT(392);
4:PRINT(393);8:PRINT(394);7:PRINT(395);3:PRINT(396);END;PRINT(397);
END{:362};P:=Q;UNTIL P=H;PRINTNL(387);ENDDIAGNOSTI(TRUE);END;{:361}
{364:}{372:}PROCEDURE SPLITCUBIC(P:HALFWORD;T:FRACTION);VAR V:SCALED;
Q,R:HALFWORD;BEGIN Q:=MEM[P].HH.RH;R:=GETNODE(7);MEM[P].HH.RH:=R;
MEM[R].HH.RH:=Q;UNROTATE(MEM[Q+1].INT,MEM[Q+2].INT,MEM[Q].HH.B1);
ROTATE(CURX,CURY,MEM[P].HH.B1);MEM[R].HH.B0:=MEM[Q].HH.B0;
MEM[R].HH.B1:=MEM[P].HH.B1;
V:=MEM[P+5].INT-TAKEFRACTION(MEM[P+5].INT-MEM[Q+3].INT,T);
MEM[P+5].INT:=MEM[P+1].INT-TAKEFRACTION(MEM[P+1].INT-MEM[P+5].INT,T);
MEM[Q+3].INT:=MEM[Q+3].INT-TAKEFRACTION(MEM[Q+3].INT-CURX,T);
MEM[R+3].INT:=MEM[P+5].INT-TAKEFRACTION(MEM[P+5].INT-V,T);
MEM[R+5].INT:=V-TAKEFRACTION(V-MEM[Q+3].INT,T);
MEM[R+1].INT:=MEM[R+3].INT-TAKEFRACTION(MEM[R+3].INT-MEM[R+5].INT,T);
V:=MEM[P+6].INT-TAKEFRACTION(MEM[P+6].INT-MEM[Q+4].INT,T);
MEM[P+6].INT:=MEM[P+2].INT-TAKEFRACTION(MEM[P+2].INT-MEM[P+6].INT,T);
MEM[Q+4].INT:=MEM[Q+4].INT-TAKEFRACTION(MEM[Q+4].INT-CURY,T);
MEM[R+4].INT:=MEM[P+6].INT-TAKEFRACTION(MEM[P+6].INT-V,T);
MEM[R+6].INT:=V-TAKEFRACTION(V-MEM[Q+4].INT,T);
MEM[R+2].INT:=MEM[R+4].INT-TAKEFRACTION(MEM[R+4].INT-MEM[R+6].INT,T);
END;{:372}{385:}PROCEDURE REMOVECUBIC(P:HALFWORD);VAR Q:HALFWORD;
BEGIN Q:=MEM[P].HH.RH;MEM[P].HH.B1:=MEM[Q].HH.B1;
MEM[P].HH.RH:=MEM[Q].HH.RH;MEM[P+1].INT:=MEM[Q+1].INT;
MEM[P+2].INT:=MEM[Q+2].INT;MEM[P+5].INT:=MEM[Q+5].INT;
MEM[P+6].INT:=MEM[Q+6].INT;FREENODE(Q,7);END;{:385}{389:}
PROCEDURE NEWBOUNDARY(P:HALFWORD;OCTANT:SMALLNUMBER);VAR Q,R:HALFWORD;
BEGIN Q:=MEM[P].HH.RH;R:=GETNODE(7);MEM[R].HH.RH:=Q;MEM[P].HH.RH:=R;
MEM[R].HH.B0:=MEM[Q].HH.B0;MEM[R+3].INT:=MEM[Q+3].INT;
MEM[R+4].INT:=MEM[Q+4].INT;MEM[R].HH.B1:=0;MEM[Q].HH.B0:=0;
MEM[R+5].INT:=OCTANT;MEM[Q+3].INT:=MEM[Q].HH.B1;
UNROTATE(MEM[Q+1].INT,MEM[Q+2].INT,MEM[Q].HH.B1);
ROTATE(CURX,CURY,OCTANT);MEM[R+1].INT:=CURX;MEM[R+2].INT:=CURY;END;
{:389}FUNCTION MAKESPEC(H:HALFWORD;SAFETYMARGIN:SCALED):HALFWORD;
LABEL 30;VAR P,Q,R,S,PP,QQ:HALFWORD;K:INTEGER;CHOPPED:BOOLEAN;
MAXALLOWED:SCALED;{369:}DEL1,DEL2,DEL3,DEL,DMAX:SCALED;T:FRACTION;{:369}
{391:}O1,O2:SMALLNUMBER;CLOCKWISE:BOOLEAN;DX1,DY1,DX2,DY2:INTEGER;{:391}
BEGIN IF INTERNAL[4]>0 THEN PRINTPATH(H,400);
MAXALLOWED:=268402687-SAFETYMARGIN;{366:}P:=H;K:=1;CHOPPED:=FALSE;
REPEAT IF ABS(MEM[P+3].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+3].INT>0 THEN MEM[P+3].INT:=MAXALLOWED ELSE MEM[P+3].INT:=-
MAXALLOWED;END;IF ABS(MEM[P+4].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+4].INT>0 THEN MEM[P+4].INT:=MAXALLOWED ELSE MEM[P+4].INT:=-
MAXALLOWED;END;IF ABS(MEM[P+1].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+1].INT>0 THEN MEM[P+1].INT:=MAXALLOWED ELSE MEM[P+1].INT:=-
MAXALLOWED;END;IF ABS(MEM[P+2].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+2].INT>0 THEN MEM[P+2].INT:=MAXALLOWED ELSE MEM[P+2].INT:=-
MAXALLOWED;END;IF ABS(MEM[P+5].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+5].INT>0 THEN MEM[P+5].INT:=MAXALLOWED ELSE MEM[P+5].INT:=-
MAXALLOWED;END;IF ABS(MEM[P+6].INT)>MAXALLOWED THEN BEGIN CHOPPED:=TRUE;
IF MEM[P+6].INT>0 THEN MEM[P+6].INT:=MAXALLOWED ELSE MEM[P+6].INT:=-
MAXALLOWED;END;P:=MEM[P].HH.RH;MEM[P].HH.B0:=K;K:=K+1;UNTIL P=H;
IF CHOPPED THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(402);END;BEGIN HELPPTR:=4;HELPLINE[3]:=403;HELPLINE[2]:=404;
HELPLINE[1]:=405;HELPLINE[0]:=406;END;ERROR;END{:366};{367:}P:=H;
REPEAT Q:=MEM[P].HH.RH;{368:}DEL1:=MEM[P+5].INT-MEM[P+1].INT;
DEL2:=MEM[Q+3].INT-MEM[P+5].INT;DEL3:=MEM[Q+1].INT-MEM[Q+3].INT;{370:}
IF DEL1<>0 THEN DEL:=DEL1 ELSE IF DEL2<>0 THEN DEL:=DEL2 ELSE DEL:=DEL3;
IF DEL<>0 THEN BEGIN DMAX:=ABS(DEL1);
IF ABS(DEL2)>DMAX THEN DMAX:=ABS(DEL2);
IF ABS(DEL3)>DMAX THEN DMAX:=ABS(DEL3);
WHILE DMAX<134217728 DO BEGIN DMAX:=DMAX+DMAX;DEL1:=DEL1+DEL1;
DEL2:=DEL2+DEL2;DEL3:=DEL3+DEL3;END;END{:370};
IF DEL<>0 THEN BEGIN IF DEL<0 THEN{371:}
BEGIN MEM[P+1].INT:=-MEM[P+1].INT-1;MEM[P+5].INT:=-MEM[P+5].INT-1;
MEM[Q+3].INT:=-MEM[Q+3].INT-1;DEL1:=-DEL1;DEL2:=-DEL2;DEL3:=-DEL3;
MEM[P].HH.B1:=2;END{:371};T:=CROSSINGPOIN(DEL1,DEL2,DEL3);
IF T<268435456 THEN{373:}BEGIN SPLITCUBIC(P,T);R:=MEM[P].HH.RH;
IF MEM[R].HH.B1>1 THEN MEM[R].HH.B1:=1 ELSE MEM[R].HH.B1:=2;
MEM[R+3].INT:=MEM[R+1].INT;MEM[R+1].INT:=-MEM[R+1].INT-1;
MEM[R+5].INT:=MEM[R+1].INT;MEM[Q+3].INT:=-MEM[Q+3].INT-1;
DEL2:=DEL2-TAKEFRACTION(DEL2-DEL3,T);IF DEL2>0 THEN DEL2:=0;
T:=CROSSINGPOIN(0,-DEL2,-DEL3);IF T<268435456 THEN{374:}
BEGIN SPLITCUBIC(R,T);R:=MEM[R].HH.RH;MEM[R].HH.B1:=MEM[P].HH.B1;
MEM[R+3].INT:=MEM[R+1].INT;MEM[R+1].INT:=-MEM[R+1].INT-1;
MEM[R+5].INT:=MEM[R+1].INT;MEM[Q+3].INT:=-MEM[Q+3].INT-1;END{:374};
END{:373};END{:368};{375:}PP:=P;REPEAT QQ:=MEM[PP].HH.RH;
DEL1:=MEM[PP+6].INT-MEM[PP+2].INT;DEL2:=MEM[QQ+4].INT-MEM[PP+6].INT;
DEL3:=MEM[QQ+2].INT-MEM[QQ+4].INT;{370:}
IF DEL1<>0 THEN DEL:=DEL1 ELSE IF DEL2<>0 THEN DEL:=DEL2 ELSE DEL:=DEL3;
IF DEL<>0 THEN BEGIN DMAX:=ABS(DEL1);
IF ABS(DEL2)>DMAX THEN DMAX:=ABS(DEL2);
IF ABS(DEL3)>DMAX THEN DMAX:=ABS(DEL3);
WHILE DMAX<134217728 DO BEGIN DMAX:=DMAX+DMAX;DEL1:=DEL1+DEL1;
DEL2:=DEL2+DEL2;DEL3:=DEL3+DEL3;END;END{:370};
IF DEL<>0 THEN BEGIN IF DEL<0 THEN{376:}
BEGIN MEM[PP+2].INT:=-MEM[PP+2].INT-1;MEM[PP+6].INT:=-MEM[PP+6].INT-1;
MEM[QQ+4].INT:=-MEM[QQ+4].INT-1;DEL1:=-DEL1;DEL2:=-DEL2;DEL3:=-DEL3;
MEM[PP].HH.B1:=MEM[PP].HH.B1+2;END{:376};
T:=CROSSINGPOIN(DEL1,DEL2,DEL3);IF T<268435456 THEN{377:}
BEGIN SPLITCUBIC(PP,T);R:=MEM[PP].HH.RH;
IF MEM[R].HH.B1>2 THEN MEM[R].HH.B1:=MEM[R].HH.B1-2 ELSE MEM[R].HH.B1:=
MEM[R].HH.B1+2;MEM[R+4].INT:=MEM[R+2].INT;MEM[R+2].INT:=-MEM[R+2].INT-1;
MEM[R+6].INT:=MEM[R+2].INT;MEM[QQ+4].INT:=-MEM[QQ+4].INT-1;
DEL2:=DEL2-TAKEFRACTION(DEL2-DEL3,T);IF DEL2>0 THEN DEL2:=0;
T:=CROSSINGPOIN(0,-DEL2,-DEL3);IF T<268435456 THEN{378:}
BEGIN SPLITCUBIC(R,T);R:=MEM[R].HH.RH;MEM[R].HH.B1:=MEM[PP].HH.B1;
MEM[R+4].INT:=MEM[R+2].INT;MEM[R+2].INT:=-MEM[R+2].INT-1;
MEM[R+6].INT:=MEM[R+2].INT;MEM[QQ+4].INT:=-MEM[QQ+4].INT-1;END{:378};
END{:377};END;PP:=QQ;UNTIL PP=Q{:375};{379:}PP:=P;
REPEAT QQ:=MEM[PP].HH.RH;{380:}
UNROTATE(MEM[QQ+1].INT,MEM[QQ+2].INT,MEM[QQ].HH.B1);
ROTATE(CURX,CURY,MEM[PP].HH.B1);DEL1:=MEM[PP+5].INT-MEM[PP+6].INT;
DEL2:=MEM[QQ+3].INT-MEM[QQ+4].INT;DEL3:=CURX-CURY-DEL2;DEL2:=DEL2-DEL1;
DEL1:=DEL1-(MEM[PP+1].INT-MEM[PP+2].INT){:380};{370:}
IF DEL1<>0 THEN DEL:=DEL1 ELSE IF DEL2<>0 THEN DEL:=DEL2 ELSE DEL:=DEL3;
IF DEL<>0 THEN BEGIN DMAX:=ABS(DEL1);
IF ABS(DEL2)>DMAX THEN DMAX:=ABS(DEL2);
IF ABS(DEL3)>DMAX THEN DMAX:=ABS(DEL3);
WHILE DMAX<134217728 DO BEGIN DMAX:=DMAX+DMAX;DEL1:=DEL1+DEL1;
DEL2:=DEL2+DEL2;DEL3:=DEL3+DEL3;END;END{:370};
IF DEL<>0 THEN BEGIN IF DEL<0 THEN{381:}BEGIN DEL:=MEM[PP+2].INT;
MEM[PP+2].INT:=MEM[PP+1].INT;MEM[PP+1].INT:=DEL;DEL:=MEM[PP+6].INT;
MEM[PP+6].INT:=MEM[PP+5].INT;MEM[PP+5].INT:=DEL;DEL:=MEM[QQ+4].INT;
MEM[QQ+4].INT:=MEM[QQ+3].INT;MEM[QQ+3].INT:=DEL;DEL1:=-DEL1;DEL2:=-DEL2;
DEL3:=-DEL3;MEM[PP].HH.B1:=MEM[PP].HH.B1+SWAPXY;END{:381};
T:=CROSSINGPOIN(DEL1,DEL2,DEL3);IF T<268435456 THEN{382:}
BEGIN SPLITCUBIC(PP,T);R:=MEM[PP].HH.RH;
IF MEM[R].HH.B1>SWAPXY THEN MEM[R].HH.B1:=MEM[R].HH.B1-SWAPXY ELSE MEM[R
].HH.B1:=MEM[R].HH.B1+SWAPXY;
MEM[R+4].INT:=MEM[R+2].INT-(MEM[R+1].INT-MEM[R+3].INT);
DEL:=MEM[R+2].INT;MEM[R+2].INT:=MEM[R+1].INT;MEM[R+1].INT:=DEL;
MEM[R+6].INT:=MEM[R+5].INT;
MEM[R+5].INT:=MEM[R+1].INT+MEM[R+6].INT-MEM[R+2].INT;DEL:=MEM[QQ+4].INT;
MEM[QQ+4].INT:=MEM[QQ+3].INT;MEM[QQ+3].INT:=DEL;
DEL2:=DEL2-TAKEFRACTION(DEL2-DEL3,T);IF DEL2>0 THEN DEL2:=0;
T:=CROSSINGPOIN(0,-DEL2,-DEL3);IF T<268435456 THEN{383:}
BEGIN SPLITCUBIC(R,T);R:=MEM[R].HH.RH;
MEM[R+4].INT:=MEM[R+2].INT-(MEM[R+1].INT-MEM[R+3].INT);
DEL:=MEM[R+2].INT;MEM[R+2].INT:=MEM[R+1].INT;MEM[R+1].INT:=DEL;
MEM[R+6].INT:=MEM[R+5].INT;
MEM[R+5].INT:=MEM[R+1].INT+MEM[R+6].INT-MEM[R+2].INT;DEL:=MEM[QQ+4].INT;
MEM[QQ+4].INT:=MEM[QQ+3].INT;MEM[QQ+3].INT:=DEL;END{:383};END{:382};END;
PP:=QQ;UNTIL PP=Q{:379};P:=Q;UNTIL P=H{:367};{384:}P:=H;
REPEAT Q:=MEM[P].HH.RH;
IF(P<>H)OR(Q<>H)THEN BEGIN IF MEM[P+1].INT=MEM[P+5].INT THEN IF MEM[P+2]
.INT=MEM[P+6].INT THEN IF MEM[P+1].INT=MEM[Q+3].INT THEN IF MEM[P+2].INT
=MEM[Q+4].INT THEN BEGIN UNROTATE(MEM[Q+1].INT,MEM[Q+2].INT,MEM[Q].HH.B1
);ROTATE(CURX,CURY,MEM[P].HH.B1);
IF MEM[P+1].INT=CURX THEN IF MEM[P+2].INT=CURY THEN BEGIN REMOVECUBIC(P)
;IF Q=H THEN H:=P;Q:=P;END;END;END;P:=Q;UNTIL P=H;{:384};{388:}
WINDINGNUMBE:=0;P:=H;Q:=MEM[P].HH.RH;REPEAT R:=MEM[Q].HH.RH;
IF(MEM[P].HH.B1<>MEM[Q].HH.B1)OR(Q=R)THEN{390:}
BEGIN NEWBOUNDARY(P,MEM[P].HH.B1);S:=MEM[P].HH.RH;
O1:=OCTANTNUMBER[MEM[P].HH.B1];O2:=OCTANTNUMBER[MEM[Q].HH.B1];
CASE O2-O1 OF 1,-7,7,-1:GOTO 30;0,2,-6:CLOCKWISE:=FALSE;
3,-5,4,-4,5,-3:{392:}BEGIN{393:}DX1:=MEM[S+1].INT-MEM[S+3].INT;
DY1:=MEM[S+2].INT-MEM[S+4].INT;
IF DX1=0 THEN IF DY1=0 THEN BEGIN DX1:=MEM[S+1].INT-MEM[P+5].INT;
DY1:=MEM[S+2].INT-MEM[P+6].INT;
IF DX1=0 THEN IF DY1=0 THEN BEGIN DX1:=MEM[S+1].INT-MEM[P+1].INT;
DY1:=MEM[S+2].INT-MEM[P+2].INT;END;END;DMAX:=ABS(DX1);
IF ABS(DY1)>DMAX THEN DMAX:=ABS(DY1);
WHILE DMAX<268435456 DO BEGIN DMAX:=DMAX+DMAX;DX1:=DX1+DX1;DY1:=DY1+DY1;
END;DX2:=MEM[Q+5].INT-MEM[Q+1].INT;DY2:=MEM[Q+6].INT-MEM[Q+2].INT;
IF DX2=0 THEN IF DY2=0 THEN BEGIN DX2:=MEM[R+3].INT-MEM[Q+1].INT;
DY2:=MEM[R+4].INT-MEM[Q+2].INT;
IF DX2=0 THEN IF DY2=0 THEN BEGIN UNROTATE(MEM[R+1].INT,MEM[R+2].INT,MEM
[R].HH.B1);ROTATE(CURX,CURY,MEM[Q].HH.B1);DX2:=CURX-MEM[Q+1].INT;
DY2:=CURY-MEM[Q+2].INT;END;END;DMAX:=ABS(DX2);
IF ABS(DY2)>DMAX THEN DMAX:=ABS(DY2);
WHILE DMAX<268435456 DO BEGIN DMAX:=DMAX+DMAX;DX2:=DX2+DX2;DY2:=DY2+DY2;
END{:393};UNROTATE(DX1,DY1,MEM[P].HH.B1);DEL:=PYTHADD(CURX,CURY);
DX1:=MAKEFRACTION(CURX,DEL);DX2:=MAKEFRACTION(CURY,DEL);
UNROTATE(DX2,DY2,MEM[P].HH.B1);DEL:=PYTHADD(CURX,CURY);
DX2:=MAKEFRACTION(CURX,DEL);DX2:=MAKEFRACTION(CURY,DEL);
DEL:=TAKEFRACTION(DX1,DY2)-TAKEFRACTION(DX2,DY1);
IF DEL<-1143 THEN CLOCKWISE:=TRUE ELSE CLOCKWISE:=FALSE;END{:392};
6,-2:CLOCKWISE:=TRUE;END;{394:}
WHILE TRUE DO BEGIN IF CLOCKWISE THEN IF O1=1 THEN O1:=8 ELSE O1:=O1-1
ELSE IF O1=8 THEN O1:=1 ELSE O1:=O1+1;IF O1=O2 THEN GOTO 30;
NEWBOUNDARY(S,OCTANTCODE[O1]);S:=MEM[S].HH.RH;
MEM[S+3].INT:=MEM[S+5].INT;END{:394};
30:IF Q=R THEN BEGIN Q:=MEM[Q].HH.RH;R:=Q;H:=Q;P:=Q;REMOVECUBIC(S);END;
{395:}P:=MEM[P].HH.RH;REPEAT S:=MEM[P].HH.RH;
O1:=OCTANTNUMBER[MEM[P+5].INT];O2:=OCTANTNUMBER[MEM[S+3].INT];
IF ABS(O1-O2)=1 THEN BEGIN WINDINGNUMBE:=WINDINGNUMBE+O2-O1;
IF O2<O1 THEN O2:=O1;
IF ODD(O2)THEN MEM[P+6].INT:=0 ELSE MEM[P+6].INT:=1;
END ELSE BEGIN IF O1=8 THEN WINDINGNUMBE:=WINDINGNUMBE+1 ELSE
WINDINGNUMBE:=WINDINGNUMBE-1;MEM[P+6].INT:=0;END;
MEM[S+4].INT:=MEM[P+6].INT;P:=S;UNTIL P=Q{:395};END{:390};P:=Q;Q:=R;
UNTIL P=H;{:388};
WHILE(MEM[H].HH.B0<>0)OR(MEM[H+3].INT<>1)DO H:=MEM[H].HH.RH;
IF INTERNAL[4]>0 THEN PRINTSPEC(H,401);MAKESPEC:=H;END;{:364}{399:}
PROCEDURE SKEW(P,Q:HALFWORD;XX0,YY0,XX1,YY1:SCALED);
VAR LAMBDANUM,LAMBDADENOM,MUNUM,MUDENOM,ALPHA,BETA:SCALED;
LAMBDA,MU:FRACTION;BEGIN{400:}MUNUM:=YY1-YY0;
MUDENOM:=MEM[Q+2].INT-MEM[P+2].INT;LAMBDANUM:=XX1-XX0;
LAMBDADENOM:=MEM[Q+1].INT-MEM[P+1].INT-MUDENOM;
IF(LAMBDANUM<0)OR(MUNUM<0)OR(LAMBDADENOM<=0)OR(MUDENOM<=0)OR((LAMBDANUM)
DIV 2>LAMBDADENOM)OR((MUNUM)DIV 2>MUDENOM)THEN BEGIN LAMBDA:=268435456;
MU:=268435456;ALPHA:=0;BETA:=32768;
END ELSE BEGIN LAMBDA:=MAKEFRACTION(LAMBDANUM,LAMBDADENOM);
MU:=MAKEFRACTION(MUNUM,MUDENOM);
ALPHA:=XX0-TAKEFRACTION(MEM[P+1].INT-MEM[P+2].INT,LAMBDA);
BETA:=YY0-TAKEFRACTION(MEM[P+2].INT,MU);END;{:400};MEM[P+1].INT:=XX0;
MEM[P+2].INT:=YY0;
REPEAT MEM[P+5].INT:=TAKEFRACTION(MEM[P+5].INT-MEM[P+6].INT,LAMBDA)+
ALPHA;MEM[P+6].INT:=TAKEFRACTION(MEM[P+6].INT,MU)+BETA;P:=MEM[P].HH.RH;
MEM[P+3].INT:=TAKEFRACTION(MEM[P+3].INT-MEM[P+4].INT,LAMBDA)+ALPHA;
MEM[P+4].INT:=TAKEFRACTION(MEM[P+4].INT,MU)+BETA;
MEM[P+1].INT:=TAKEFRACTION(MEM[P+1].INT-MEM[P+2].INT,LAMBDA)+ALPHA;
MEM[P+2].INT:=TAKEFRACTION(MEM[P+2].INT,MU)+BETA;UNTIL P=Q;END;{:399}
{401:}MAKEGOOD(X,Y:SCALED;TRANSITION:SMALLNUMBER;INCOMING:BOOLEAN);
VAR THETA,PHI,AVE:SCALED;BEGIN X:=X+32768;CURM:=TRUNCUNSCALE(X);
CURX:=CURM*65536;THETA:=X-CURX;Y:=Y+32768;CURN:=TRUNCUNSCALE(Y);
CURY:=CURN*65536;PHI:=Y-CURY;IF THETA>=PHI THEN CURD:=1 ELSE CURD:=0;
IF TRANSITION=0 THEN CURX:=X-32768 ELSE BEGIN AVE:=(THETA+PHI)DIV 2;
IF AVE<16384 THEN AVE:=16384 ELSE IF AVE>=49152 THEN AVE:=49151;
IF INCOMING THEN PHI:=PHI+1;IF THETA<PHI THEN BEGIN THETA:=AVE-49152;
PHI:=AVE-16384;END ELSE BEGIN THETA:=AVE-16384;PHI:=AVE-49152;END;
CURX:=CURX+THETA;CURY:=CURY+PHI;END;END;{:401}{403:}
PROCEDURE FILLSPEC(H:HALFWORD);VAR P,Q,R,S:HALFWORD;M0,N0,M1,N1:INTEGER;
XX0,YY0:SCALED;OCTANT:SMALLNUMBER;BEGIN P:=H;
REPEAT OCTANT:=MEM[P+3].INT;{404:}Q:=P;
WHILE MEM[Q].HH.B1<>0 DO Q:=MEM[Q].HH.RH{:404};IF Q<>P THEN BEGIN{405:}
MAKEGOOD(MEM[P+1].INT,MEM[P+2].INT,MEM[P+4].INT,TRUE);M0:=CURM;N0:=CURN;
D0:=CURD;XX0:=CURX-CURY;YY0:=CURY+32768;
MAKEGOOD(MEM[Q+1].INT,MEM[Q+2].INT,MEM[Q+6].INT,FALSE);M1:=CURM;
N1:=CURN;D1:=CURD;SKEW(P,Q,XX0,YY0,CURX-CURY,CURY+32768){:405};{406:}
IF N1-N0>=MOVESIZE THEN OVERFLOW(407,MOVESIZE);MOVE[0]:=D0;MOVEPTR:=0;
R:=P;REPEAT S:=MEM[R].HH.RH;
MAKEMOVES(MEM[R+1].INT,MEM[R+5].INT,MEM[S+3].INT,MEM[S+1].INT,MEM[R+2].
INT,MEM[R+6].INT,MEM[S+4].INT,MEM[S+2].INT);R:=S;UNTIL R=Q;
MOVE[MOVEPTR]:=MOVE[MOVEPTR]-D1{:406};MOVETOEDGES(M0,N0,M1,N1,OCTANT);
END;P:=MEM[Q].HH.RH;UNTIL P=H;TOSSKNOTLIST(H);END;{:403}{411:}
PROCEDURE PRINTPEN(P:HALFWORD;S:STRNUMBER);VAR NOTHINGPRINT:BOOLEAN;
K,OCTANT:1..8;H:HALFWORD;M,N:INTEGER;W,WW:HALFWORD;
M:INTEGER BEGIN PRINTDIAGNOS(408,S);NOTHINGPRINT:=TRUE;
FOR K:=1 TO 8 DO BEGIN OCTANT:=OCTANTCODE[K];H:=P+OCTANT;
N:=MEM[H].HH.LH;W:=MEM[H].HH.RH;IF NOT ODD(K)THEN W:=MEM[W].HH.LH;
FOR M:=1 TO N+1 DO BEGIN IF ODD(K)THEN WW:=MEM[W].HH.RH ELSE WW:=MEM[W].
HH.LH;
IF(MEM[WW+1].INT<>MEM[W+1].INT)OR(MEM[WW+2].INT<>MEM[WW+2].INT)THEN{412:
}BEGIN IF NOTHINGPRINT THEN BEGIN PRINTLN;NOTHINGPRINT:=FALSE;
END ELSE PRINTNL(398);
CASE OCTANT OF 1:PRINTTWO(MEM[WW+1].INT+MEM[WW+2].INT,MEM[WW+2].INT);
5:PRINTTWO(MEM[WW+2].INT,MEM[WW+1].INT+MEM[WW+2].INT);
6:PRINTTWO(-MEM[WW+2].INT,MEM[WW+1].INT,MEM[WW+2].INT);
2:PRINTTWO(-MEM[WW+1].INT-MEM[WW+2].INT,MEM[WW+2].INT);
4:PRINTTWO(-MEM[WW+1].INT-MEM[WW+2].INT-MEM[WW+2].INT);
8:PRINTTWO(-MEM[WW+2].INT,-MEM[WW+1].INT-MEM[WW+2].INT);
7:PRINTTWO(MEM[WW+2].INT,-MEM[WW+1].INT-MEM[WW+2].INT);
3:PRINTTWO(MEM[WW+1].INT+MEM[WW+2].INT,-MEM[WW+2].INT);END;END{:412};
W:=WW;END;END;IF NOTHINGPRINT THEN BEGIN W:=MEM[P].HH.RH;
PRINTTWO(MEM[W+1].INT+MEM[W+2].INT,MEM[W+2].INT);END;PRINTNL(409);
ENDDIAGNOSTI(TRUE);END;{:411}{414:}PROCEDURE DUPOFFSET(W:HALFWORD);
VAR R:HALFWORD;BEGIN R:=GETNODE(3);MEM[R+1].INT:=MEM[W+1].INT;
MEM[R+2].INT:=MEM[W+2].INT;MEM[R].HH.RH:=MEM[W].HH.RH;
MEM[MEM[W].HH.RH].HH.LH:=R;MEM[R].HH.LH:=W;MEM[W].HH.RH:=R;END;{:414}
{415:}PROCEDURE MAKEPEN(H:HALFWORD):HALFWORD;LABEL 30,31,45,40;
VAR O,OO,K:SMALLNUMBER;P:HALFWORD;Q,R,S,W,WW,H,HH:HALFWORD;N:INTEGER;
DX,DY:SCALED;OCTANT:1..8;BEGIN{418:}Q:=H;R:=MEM[Q].HH.RH;
IF Q=R THEN BEGIN HH:=H;MEM[H].HH.B1:=0;END ELSE BEGIN O:=0;HH:=0;
WHILE TRUE DO BEGIN S:=MEM[R].HH.RH;DX:=MEM[R+1].INT-MEM[Q+1].INT;
DY:=MEM[R+2].INT-MEM[Q+2].INT;IF DX=0 THEN IF DY=0 THEN GOTO 45;
IF NOT ABGEQCD(DX,MEM[S+2].INT-MEM[R+2].INT,DY,MEM[S+1].INT-MEM[R+1].INT
)THEN GOTO 45;{419:}OCTANT:=1;IF DX<0 THEN BEGIN DX:=-DX;OCTANT:=2;END;
IF DY<0 THEN BEGIN DY:=-DY;OCTANT:=OCTANT+2;END;
IF DX<DY THEN OCTANT:=OCTANT+SWAPXY{:419};MEM[Q].HH.B1:=OCTANT;
OO:=OCTANTNUMBER[OCTANT];IF O>OO THEN BEGIN IF HH<>0 THEN GOTO 45;HH:=Q;
END;O:=OO;IF(Q=H)AND(HH<>0)THEN GOTO 30;Q:=R;R:=S;END;30:END{:418};
P:=GETNODE(10);Q:=HH;FOR K:=1 TO 8 DO{420:}OCTANT:=OCTANTCODE(K);N:=0;
H:=P+OCTANT;WHILE TRUE DO BEGIN R:=GETNODE(3);{421:}
CASE OCTANT OF 1:BEGIN MEM[R+1].INT:=MEM[Q+1].INT-MEM[Q+2].INT;
MEM[R+2].INT:=MEM[Q+2].INT;END;
5:BEGIN MEM[R+1].INT:=MEM[Q+2].INT-MEM[Q+1].INT;
MEM[R+2].INT:=MEM[Q+1].INT;END;
6:BEGIN MEM[R+1].INT:=MEM[Q+2].INT+MEM[Q+1].INT;
MEM[R+2].INT:=-MEM[Q+1].INT;END;
2:BEGIN MEM[R+1].INT:=-MEM[Q+1].INT-MEM[Q+2].INT;
MEM[R+2].INT:=MEM[Q+2].INT;END;
4:BEGIN MEM[R+1].INT:=-MEM[Q+1].INT+MEM[Q+2].INT;
MEM[R+2].INT:=-MEM[Q+2].INT;END;
8:BEGIN MEM[R+1].INT:=-MEM[Q+2].INT+MEM[Q+1].INT;
MEM[R+2].INT:=-MEM[Q+1].INT;END;
7:BEGIN MEM[R+1].INT:=-MEM[Q+2].INT-MEM[Q+1].INT;
MEM[R+2].INT:=MEM[Q+1].INT;END;
3:BEGIN MEM[R+1].INT:=MEM[Q+1].INT+MEM[Q+2].INT;
MEM[R+2].INT:=-MEM[Q+2].INT;END;END{:421};
IF N=0 THEN MEM[H].HH.RH:=R ELSE{422:}
IF ODD(K)THEN BEGIN MEM[W].HH.RH:=R;MEM[R].HH.LH:=W;
END ELSE BEGIN MEM[W].HH.LH:=R;MEM[R].HH.RH:=W;END{:422};W:=R;
IF MEM[Q].HH.B1<>OCTANT THEN GOTO 31;Q:=MEM[Q].HH.RH;N:=N+1;END;
31:{423:}R:=MEM[H].HH.RH;IF ODD(K)THEN BEGIN MEM[W].HH.RH:=R;
MEM[R].HH.LH:=W;END ELSE BEGIN MEM[W].HH.LH:=R;MEM[R].HH.RH:=W;
MEM[H].HH.RH:=W;R:=W;END;
IF MEM[R+2].INT<>MEM[MEM[R].HH.RH+2].INT THEN BEGIN DUPOFFSET(R);N:=N+1;
END;R:=MEM[R].HH.LH;
IF MEM[R+1].INT<>MEM[MEM[R].HH.LH+1].INT THEN DUPOFFSET(R)ELSE N:=N-1{:
423};MEM[H].HH.LH:=N{:420};GOTO 40;45:P:=3;{416:}
BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(411);END;
BEGIN HELPPTR:=3;HELPLINE[2]:=412;HELPLINE[1]:=413;HELPLINE[0]:=414;END;
ERROR{:416};40:IF INTERNAL[5]>0 THEN PRINTPEN(P,410);MAKEPEN:=P;END;
{:415}{424:}PROCEDURE TOSSPEN(P:HALFWORD);VAR K:0..7;W,WW:HALFWORD;
BEGIN IF P<>3 THEN BEGIN FOR K:=0 TO 7 DO BEGIN W:=MEM[P+K].HH.RH;
REPEAT WW:=MEM[W].HH.RH;FREENODE(W,3);W:=WW;UNTIL W=MEM[P+K].HH.RH;
FREENODE(P,10);END;END;{:424}{426:}{428:}
PROCEDURE SPLITFOROFFS(P:HALFWORD;T:FRACTION);VAR Q:HALFWORD;
S:QUARTERWORD;BEGIN Q:=MEM[P].HH.RH;S:=MEM[Q].HH.B1;MEM[Q].HH.B1:=1;
MEM[P].HH.B1:=1;SPLITCUBIC(P,T);MEM[Q].HH.B1:=S;END;{:428}{432:}
PROCEDURE FINOFFSETPRE(P:HALFWORD;K:HALFWORD;W:HALFWORD;
X0,X1,X2,Y0,Y1,Y2:INTEGER;RISING:BOOLEAN);LABEL 10;VAR Q,WW:HALFWORD;
DU,DV:SCALED;T0,T1,T2:INTEGER;T:FRACTION;V:INTEGER;
BEGIN WHILE TRUE DO BEGIN Q:=MEM[P].HH.RH;MEM[P].HH.B1:=K;
IF RISING THEN IF K=N THEN GOTO 10 ELSE WW:=MEM[W].HH.RH ELSE IF K=0
THEN GOTO 10 ELSE WW:=MEM[W].HH.LH;{433:}DU:=MEM[WW+1].INT-MEM[W+1].INT;
DV:=MEM[WW+2].INT-MEM[W+2].INT;
IF ABS(DU)>=ABS(DV)THEN BEGIN T0:=TAKEFRACTION(X0,MAKEFRACTION(DV,DU))-
Y0;T1:=TAKEFRACTION(X1,MAKEFRACTION(DV,DU))-Y1;
T2:=TAKEFRACTION(X2,MAKEFRACTION(DV,DU))-Y2;
END ELSE BEGIN T0:=X0-TAKEFRACTION(Y0,MAKEFRACTION(DU,DV));
T1:=X1-TAKEFRACTION(Y1,MAKEFRACTION(DU,DV));
T2:=X2-TAKEFRACTION(Y2,MAKEFRACTION(DU,DV));END{:433};
T:=CROSSINGPOIN(T0,T1,T2);IF T>=268435456 THEN GOTO 10;{434:}
BEGIN SPLITFOROFFS(P,T);MEM[P].HH.B1:=K;P:=MEM[P].HH.RH;
V:=X0-TAKEFRACTION(X0-X1,T);X1:=X1-TAKEFRACTION(X1-X2,T);
X0:=V-TAKEFRACTION(V-X1,T);V:=Y0-TAKEFRACTION(Y0-Y1,T);
Y1:=Y1-TAKEFRACTION(Y1-Y2,T);Y0:=V-TAKEFRACTION(V-Y1,T);
T1:=T1-TAKEFRACTION(T1-T2,T);IF T1>0 THEN T1:=0;
T:=CROSSINGPOIN(0,-T1,-T2);IF T<268435456 THEN BEGIN SPLITFOROFFS(P,T);
MEM[Q].HH.B1:=K;V:=X1-TAKEFRACTION(X1-X2,T);
X1:=X0-TAKEFRACTION(X0-X1,T);X2:=X1-TAKEFRACTION(X1-V,T);
V:=Y1-TAKEFRACTION(Y1-Y2,T);Y1:=Y0-TAKEFRACTION(Y0-Y1,T);
Y2:=Y1-TAKEFRACTION(Y1-V,T);END;END{:434};
IF RISING THEN K:=K+1 ELSE K:=K-1;W:=WW;END;10:END;{:432}
PROCEDURE OFFSETPREP(C,H:HALFWORD);LABEL 30;VAR N:HALFWORD;
P,Q,R,WW:HALFWORD;K:HALFWORD;W:HALFWORD;{430:}X0,X1,X2,Y0,Y1,Y2:INTEGER;
T0,T1,T2:INTEGER;DU,DV,DX,DY:INTEGER;MAXCOEF:INTEGER;
X0A,X1A,X2A,Y0A,Y1A,Y2A:INTEER;{:430}BEGIN P:=C;N:=MEM[H].HH.LH;
H:=MEM[H].HH.RH;WHILE MEM[P].HH.B1<>0 DO BEGIN Q:=MEM[P].HH.RH;{429:}
IF N=1 THEN MEM[P].HH.B1:=1 ELSE BEGIN{431:}X0:=MEM[P+5].INT-XCOEFF(P);
X2:=XCOEFF(Q)-MEM[Q+3].INT;X1:=MEM[Q+3].INT-MEM[P+5].INT;
Y0:=MEM[P+6].INT-YCOEFF(P);Y2:=YCOEFF(Q)-MEM[Q+4].INT;
Y1:=MEM[Q+4].INT-MEM[P+6].INT;MAXCOEF:=ABS(X0);
IF ABS(X1)>MAXCOEF THEN MAXCOEF:=ABS(X1);
IF ABS(X2)>MAXCOEF THEN MAXCOEF:=ABS(X2);
IF ABS(Y0)>MAXCOEF THEN MAXCOEF:=ABS(Y0);
IF ABS(Y1)>MAXCOEF THEN MAXCOEF:=ABS(Y1);
IF ABS(Y2)>MAXCOEF THEN MAXCOEF:=ABS(Y2);
WHILE MAXCOEF<268435456 DO BEGIN MAXCOEF:=MAXCOEF+MAXCOEF;X0:=X0+X0;
X1:=X1+X1;X2:=X2+X2;Y0:=Y0+Y0;Y1:=Y1+Y1;Y2:=Y2+Y2;END;{:431};
IF DX=0 THEN{440:}
FINOFFSETPRE(P,N,MEM[MEM[H].HH.LH].HH.LH,-X0,-X1,-X2,-Y0,-Y1,-Y2,FALSE){
:440}ELSE BEGIN{436:}DX:=X0;DY:=Y0;
IF DX=0 THEN IF DY=0 THEN BEGIN DX:=X1;DY:=Y1;
IF DX=0 THEN IF DY=0 THEN BEGIN DX:=X2;DY:=Y2;END;END{:436};{437:}K:=1;
W:=MEM[H].HH.RH;WHILE TRUE DO BEGIN WW:=MEM[W].HH.RH;
IF K<N THEN IF ABGEQCD(DY,ABS(MEM[WW+1].INT-MEM[W+1].INT),DX,ABS(MEM[WW
+2].INT-MEM[W+2].INT))THEN BEGIN K:=K+1;W:=WW;END ELSE GOTO 30;END;
30:{:437};{438:}IF K=1 THEN T:=268435457 ELSE BEGIN WW:=MEM[W].HH.LH;
{433:}DU:=MEM[WW+1].INT-MEM[W+1].INT;DV:=MEM[WW+2].INT-MEM[W+2].INT;
IF ABS(DU)>=ABS(DV)THEN BEGIN T0:=TAKEFRACTION(X0,MAKEFRACTION(DV,DU))-
Y0;T1:=TAKEFRACTION(X1,MAKEFRACTION(DV,DU))-Y1;
T2:=TAKEFRACTION(X2,MAKEFRACTION(DV,DU))-Y2;
END ELSE BEGIN T0:=X0-TAKEFRACTION(Y0,MAKEFRACTION(DU,DV));
T1:=X1-TAKEFRACTION(Y1,MAKEFRACTION(DU,DV));
T2:=X2-TAKEFRACTION(Y2,MAKEFRACTION(DU,DV));END{:433};
T:=CROSSINGPOIN(T0,T1,T2);END;
IF T>=268435456 THEN FINOFFSETPRE(P,K,W,X0,X1,X2,Y0,Y1,Y2,TRUE)ELSE
BEGIN SPLITFOROFFS(P,T);R:=MEM[P].HH.RH;X1A:=X0-TAKEFRACTION(X0-X1,T);
X1:=X1-TAKEFRACTION(X1-X2,T);X2A:=X10-TAKEFRACTION(X10-X1,T);
Y1A:=Y0-TAKEFRACTION(Y0-Y1,T);Y1:=Y1-TAKEFRACTION(Y1-Y2,T);
Y2A:=Y10-TAKEFRACTION(Y10-Y1,T);
FINOFFSETPRE(P,K,W,X0,X1A,X2A,Y0,Y1A,Y2A,TRUE);X0:=X2A;Y0:=Y2A;
T1:=T1-TAKEFRACTION(T1-T2,T);IF T1>0 THEN T1:=0;
T:=CROSSINGPOIN(0,-T1,-T2);IF T<268435456 THEN{439:}
BEGIN SPLITFOROFFS(R,T);X1A:=X1-TAKEFRACTION(X1-X2,T);
X1:=X0-TAKEFRACTION(X0-X1,T);X0A:=X1-TAKEFRACTION(X1-X1A,T);
Y1A:=Y1-TAKEFRACTION(Y1-Y2,T);Y1:=Y0-TAKEFRACTION(Y0-Y1,T);
Y0A:=Y1-TAKEFRACTION(Y1-Y1A,T);
FINOFFSETPRE(MEM[R].HH.RH,K,W,X0A,X1A,X2,Y0A,Y1A,Y2,TRUE);X2:=X0A;
Y2:=Y0A;END{:439};FINOFFSETPRE(R,K-1,WW,-X0,-X1,-X2,-Y0,-Y1,-Y2,FALSE);
END{:438};END;END{:429};{427:}REPEAT R:=MEM[P].HH.RH;
IF MEM[P+1].INT=MEM[P+5].INT THEN IF MEM[P+2].INT=MEM[P+6].INT THEN IF
MEM[P+1].INT=MEM[R+3].INT THEN IF MEM[P+2].INT=MEM[R+4].INT THEN IF MEM[
P+1].INT=MEM[R+1].INT THEN IF MEM[P+2].INT=MEM[R+2].INT THEN BEGIN
REMOVECUBIC(P);IF R=Q THEN Q:=P;R:=P;END;P:=R;UNTIL P=Q{:427};END;END;
{:426}{441:}{447:}PROCEDURE SKEWLINEEDGE(X0,Y0,X1,Y1:SCALED;
OCTANT:SMALLNUMBER);BEGIN UNROTATE(X0+Y0,Y0-32768,OCTANT);X0:=CURX;
Y0:=CURY;UNROTATE(X1+Y1,Y1-32768,OCTANT);LINEEDGES(X0,Y0,CURX,CURY);END;
{:447}PROCEDURE FILLENVELOPE(SPECHEAD,PENHEAD:HALFWORD);LABEL 30,31,32;
VAR P,Q,R,S:HALFWORD;H:HALFWORD;M0,N0,M1,N1:INTEGER;
XX,YY,XP,YP,DELX,DELY,TEMP:SCALED;OCTANT:SMALLNUMBER;{444:}
XX0,YY0,XX1,YY1:SCALED;MM0,NN0,MM1,NN1:INTEGER;M,N:INTEGER;K:INTEGER;
W,WW:HALFWORD;{:444}BEGIN P:=SPECHEAD;REPEAT OCTANT:=MEM[P+3].INT;
H:=PENHEAD+OCTANT-1;{404:}Q:=P;
WHILE MEM[Q].HH.B1<>0 DO Q:=MEM[Q].HH.RH{:404};{442:}X0:=MEM[P+1].INT;
Y0:=MEM[P+2].INT;X1:=MEM[Q+1].INT;Y1:=MEM[Q+2].INT;W:=MEM[H].HH.RH;
IF MEM[P+4].INT=1 THEN W:=MEM[W].HH.LH;
MAKEGOOD(X0+MEM[W+1].INT+MEM[W+2].INT,Y0+MEM[W+2].INT,MEM[P+4].INT,TRUE)
;M0:=CURM;N0:=CURN;D0:=CURD;XX:=(CURX-CURY)-MEM[W+1].INT;
YY:=CURY+32768-MEM[W+2].INT;W:=MEM[H].HH.RH;
IF MEM[Q+6].INT=1 THEN W:=MEM[W].HH.LH;
MAKEGOOD(X1+MEM[W+1].INT+MEM[W+2].INT,Y1+MEM[W+2].INT,MEM[Q+6].INT,FALSE
);M1:=CURM;N1:=CURN;D1:=CURD;
SKEW(P,Q,XX,YY,CURX-CURY-MEM[W+1].INT,CURY+32768-MEM[W+2].INT){:442};
OFFSETPREP(P,H);{445:}IF ODD(OCTANTNUMBER[OCTANT])THEN BEGIN{446:}K:=0;
W:=MEM[H].HH.RH;WW:=MEM[W].HH.LH;XX0:=MEM[P+1].INT+MEM[W+1].INT;
YY0:=MEM[P+2].INT+MEM[W+2].INT;IF MEM[P+4].INT=1 THEN{448:}
BEGIN SKEWLINEEDGE(MEM[P+1].INT+MEM[WW+1].INT,MEM[P+2].INT+MEM[WW+2].INT
,XX0,YY0,OCTANT);XX:=XX0+YY0;YY:=YY0-32768;M0:=ROUNDUNSCALE(XX);
N0:=ROUNDUNSCALE(YY);IF XX-M0*65536>=YY-N0*65536 THEN D0:=1 ELSE D0:=0;
END{:448};XX1:=MEM[Q+1].INT+MEM[WW+1].INT;
YY1:=MEM[Q+2].INT+MEM[WW+2].INT;NN0:=TRUNCUNSCALE(YY0);
NN1:=TRUNCUNSCALE(YY1);IF NN1-NN0>=MOVESIZE THEN OVERFLOW(407,MOVESIZE);
MM0:=TRUNCUNSCALE(XX0);MM1:=TRUNCUNSCALE(XX1);
FOR MOVEPTR:=0 TO NN1-NN0 DO ENVMOVE[MOVEPTR]:=MM0;
ENVMOVE[NN1-NN0]:=MM1;MOVEPTR:=0;M:=MM0{:446};R:=P;
MEM[Q].HH.B1:=MEM[H].HH.LH+1;
WHILE TRUE DO BEGIN WHILE MEM[R].HH.B1<>K DO{450:}
BEGIN XX:=MEM[R+1].INT+MEM[W+1].INT;YY:=MEM[R+2].INT+MEM[W+2].INT;
IF MEM[R].HH.B1>K THEN BEGIN K:=K+1;W:=MEM[W].HH.RH;
XP:=MEM[R+1].INT+MEM[W+1].INT;YP:=MEM[R+2].INT+MEM[W+2].INT;
IF(XP<>XX)OR(YP<>YY)THEN{451:}BEGIN TEMP:=TRUNCSCALED(YY);YY:=YY-TEMP;
YP:=YP-TEMP;IF YP>=65536 THEN BEGIN DELX:=XP-XX;DELY:=YP-YY;
YY:=65535-YY;
WHILE TRUE DO BEGIN M:=ROUNDUNSCALE(XX+TAKEFRACTION(DELX,MAKEFRACTION(YY
,DELY)));IF M>ENVMOVE[MOVEPTR]THEN ENVMOVE[MOVEPTR]:=M;YP:=YP-65536;
IF YP<65536 THEN GOTO 31;YY:=YY+65536;MOVEPTR:=MOVEPTR+1;END;31:END;
END{:451};END ELSE BEGIN K:=K-1;W:=MEM[W].HH.LH;
XP:=MEM[R+1].INT+MEM[W+1].INT;YP:=MEM[R+2].INT+MEM[W+2].INT;END;
M:=TRUNCUNSCALE(XP);MOVEPTR:=TRUNCUNSCALE(YP)-NN0;END{:450};
IF R=Q THEN GOTO 30;MOVE[MOVEPTR]:=0;N:=MOVEPTR;S:=MEM[R].HH.RH;
MAKEMOVES(MEM[R+1].INT+MEM[W+1].INT,MEM[R+5].INT+MEM[W+1].INT,MEM[S+3].
INT+MEM[W+1].INT,MEM[S+1].INT+MEM[W+1].INT,MEM[R+2].INT+MEM[W+2].INT,MEM
[R+6].INT+MEM[W+2].INT,MEM[S+4].INT+MEM[W+2].INT,MEM[S+2].INT+MEM[W+2].
INT);{449:}REPEAT M:=M+MOVE[N]-1;IF M>ENVMOVE[N]THEN ENVMOVE[N]:=M;
N:=N+1;UNTIL N>MOVEPTR{:449};R:=S;END;{452:}
IF MEM[Q+6].INT=0 THEN BEGIN XX:=XX1+YY1;YY:=YY1-32768;
M1:=ROUNDUNSCALE(XX);N1:=ROUNDUNSCALE(YY);
IF XX-M1*65536>=YY-N1*65536 THEN D1:=1 ELSE D1:=0;END;
MOVE[0]:=D0+ENVMOVE[0]-MM0;
FOR N:=1 TO MOVEPTR DO MOVE[N]:=ENVMOVE[N]-ENVMOVE[N-1]+1;
MOVE[MOVEPTR]:=MOVE[MOVEPTR]-D1;SMOOTHMOVES;
MOVETOEDGES(M0,N0,M1,N1,OCTANT);
IF MEM[Q+6].INT=0 THEN BEGIN WW:=MEM[H].HH.RH;
SKEWLINEEDGE(XX1,YY1,MEM[Q+1].INT+MEM[WW+1].INT,MEM[Q+2].INT+MEM[WW+2].
INT,OCTANT);END{:452};END ELSE{453:}BEGIN{454:}K:=MEM[H].HH.LH+1;
WW:=MEM[H].HH.RH;W:=MEM[WW].HH.LH;XX0:=MEM[P+1].INT+MEM[W+1].INT;
YY0:=MEM[P+2].INT+MEM[W+2].INT;IF MEM[P+4].INT=0 THEN{448:}
BEGIN SKEWLINEEDGE(MEM[P+1].INT+MEM[WW+1].INT,MEM[P+2].INT+MEM[WW+2].INT
,XX0,YY0,OCTANT);XX:=XX0+YY0;YY:=YY0-32768;M0:=ROUNDUNSCALE(XX);
N0:=ROUNDUNSCALE(YY);IF XX-M0*65536>=YY-N0*65536 THEN D0:=1 ELSE D0:=0;
END{:448};XX1:=MEM[Q+1].INT+MEM[WW+1].INT;
YY1:=MEM[Q+2].INT+MEM[WW+2].INT;NN0:=TRUNCUNSCALE(YY0);
NN1:=TRUNCUNSCALE(YY1);IF NN1-NN0>=MOVESIZE THEN OVERFLOW(407,MOVESIZE);
MM0:=TRUNCUNSCALE(XX0);MM1:=TRUNCUNSCALE(XX1);
FOR MOVEPTR:=1 TO NN1-NN0 DO ENVMOVE[MOVEPTR]:=MM1;ENVMOVE[0]:=MM0;
MOVEPTR:=0;M:=MM0{:454};R:=P;MEM[Q].HH.B1:=0;
WHILE TRUE DO BEGIN WHILE MEM[R].HH.B1<>K DO{456:}
BEGIN XX:=MEM[R+1].INT+MEM[W+1].INT;YY:=MEM[R+2].INT+MEM[W+2].INT;
IF MEM[R].HH.B1<K THEN BEGIN K:=K-1;W:=MEM[W].HH.LH;
XP:=MEM[R+1].INT+MEM[W+1].INT;YP:=MEM[R+2].INT+MEM[W+2].INT;
IF(XP<>XX)OR(YP<>YY)THEN{457:}BEGIN TEMP:=TRUNCSCALED(YY);YY:=YY-TEMP;
YP:=YP-TEMP;IF YP>=65536 THEN BEGIN DELX:=XP-XX;DELY:=YP-YY;
YY:=65535-YY;
WHILE TRUE DO BEGIN M:=ROUNDUNSCALE(XX+TAKEFRACTION(DELX,MAKEFRACTION(YY
,DELY)));IF M<ENVMOVE[MOVEPTR]THEN ENVMOVE[MOVEPTR]:=M;YP:=YP-65536;
IF YP<65536 THEN GOTO 32;YY:=YY+65536;MOVEPTR:=MOVEPTR+1;END;32:END;
END{:457};END ELSE BEGIN K:=K+1;W:=MEM[W].HH.RH;
XP:=MEM[R+1].INT+MEM[W+1].INT;YP:=MEM[R+2].INT+MEM[W+2].INT;END;
M:=TRUNCUNSCALE(XP);MOVEPTR:=TRUNCUNSCALE(YP)-NN0;END{:456};
IF R=Q THEN GOTO 30;MOVE[MOVEPTR]:=0;N:=MOVEPTR;S:=MEM[R].HH.RH;
MAKEMOVES(MEM[R+1].INT+MEM[W+1].INT,MEM[R+5].INT+MEM[W+1].INT,MEM[S+3].
INT+MEM[W+1].INT,MEM[S+1].INT+MEM[W+1].INT,MEM[R+2].INT+MEM[W+2].INT,MEM
[R+6].INT+MEM[W+2].INT,MEM[S+4].INT+MEM[W+2].INT,MEM[S+2].INT+MEM[W+2].
INT);{455:}REPEAT M:=M+MOVE[N]-1;IF M<ENVMOVE[N]THEN ENVMOVE[N]:=M;
N:=N+1;UNTIL N>MOVEPTR{:455};R:=S;END;{458:}
IF MEM[Q+6].INT=1 THEN BEGIN XX:=XX1+YY1;YY:=YY1-32768;
M1:=ROUNDUNSCALE(XX);N1:=ROUNDUNSCALE(YY);
IF XX-M1*65536>=YY-N1*65536 THEN D1:=1 ELSE D1:=0;END;
MOVE[0]:=D0+ENVMOVE[0]-MM0;
FOR N:=1 TO MOVEPTR DO MOVE[N]:=ENVMOVE[N]-ENVMOVE[N-1]+1;
MOVE[MOVEPTR]:=MOVE[MOVEPTR]-D1;SMOOTHMOVES;
MOVETOEDGES(M0,N0,M1,N1,OCTANT);
IF MEM[Q+6].INT=1 THEN BEGIN WW:=MEM[H].HH.RH;
SKEWLINEEDGE(XX1,YY1,MEM[Q+1].INT+MEM[WW+1].INT,MEM[Q+2].INT+MEM[WW+2].
INT,OCTANT);END{:458};END{:453};30:{:445};P:=MEM[Q].HH.RH;
UNTIL P=SPECHEAD;TOSSKNOTLIST(SPECHEAD);END;{:441}{462:}
FUNCTION MAKEELLIPSE(MAJORAXIS,MINORAXIS:SCALED;THETA:ANGLE):HALFWORD;
VAR P,Q,R,S:HALFWORD;H:HALFWORD;ALPHA,BETA,GAMMA,DELTA:INTEGER;
C,D:INTEGER;U,V:INTEGER;BEGIN{463:}P:=GETNODE(7);Q:=GETNODE(7);
R:=GETNODE(7);S:=GETNODE(7);H:=P;MEM[P].HH.RH:=Q;MEM[Q].HH.RH:=R;
MEM[R].HH.RH:=S;{464:}
IF(THETA=0)OR(MAJORAXIS=MINORAXIS)THEN BEGIN ALPHA:=0;BETA:=MINORAXIS;
GAMMA:=MAJORAXIS;END ELSE BEGIN NSINCOS(THETA);
GAMMA:=TAKEFRACTION(MAJORAXIS,NSIN);DELTA:=TAKEFRACTION(MINORAXIS,NCOS);
BETA:=PYTHADD(GAMMA,DELTA);
ALPHA:=TAKEFRACTION(TAKEFRACTION(MAJORAXIS,MAKEFRACTION(GAMMA,BETA)),
NCOS)-TAKEFRACTION(TAKEFRACTION(MINORAXIS,MAKEFRACTION(DELTA,BETA)),NSIN
);ALPHA:=(ALPHA+32768)DIV 65536;
GAMMA:=PYTHADD(TAKEFRACTION(MAJORAXIS,NCOS),TAKEFRACTION(MINORAXIS,NSIN)
);END;BETA:=(BETA+32768)DIV 65536;GAMMA:=(GAMMA+32768)DIV 65536{:464};
IF BETA=0 THEN BETA:=1;IF GAMMA<=ABS(ALPHA)THEN GAMMA:=ABS(ALPHA)+1;
MEM[S+1].INT:=ALPHA*32768;MEM[P+1].INT:=-MEM[S+1].INT;
MEM[S+2].INT:=BETA*32768;MEM[P+2].INT:=-MEM[S+2].INT;
MEM[Q+2].INT:=MEM[P+2].INT;MEM[R+2].INT:=MEM[S+2].INT;
MEM[Q+1].INT:=GAMMA*32768;MEM[R+1].INT:=MEM[Q+1].INT;RIGHTU(P):=0;
LEFTV(Q):=-32768;RIGHTU(Q):=32768;LEFTV(R):=0;RIGHTU(R):=0;
LEFTV(S):=32768;RIGHTCLASS(P):=BETA;RIGHTCLASS(Q):=GAMMA;
RIGHTCLASS(R):=BETA;LEFTLENGTH(Q):=GAMMA+ALPHA;LEFTLENGTH(R):=BETA+BETA;
LEFTLENGTH(S):=GAMMA-ALPHA{:463};{465:}REPEAT U:=RIGHTU(P)+RIGHTU(Q);
V:=LEFTV(Q)+LEFTV(R);C:=RIGHTCLASS(P)+RIGHTCLASS(Q);{466:}
DELTA:=PYTHADD(U,V);
IF MAJORAXIS=MINORAXIS THEN D:=MAJORAXIS ELSE BEGIN IF THETA=0 THEN
BEGIN ALPHA:=U;BETA:=V;
END ELSE BEGIN ALPHA:=TAKEFRACTION(U,NCOS)+TAKEFRACTION(V,NSIN);
BETA:=TAKEFRACTION(V,NCOS)-TAKEFRACTION(U,NSIN);END;
ALPHA:=MAKEFRACTION(ALPHA,DELTA);BETA:=MAKEFRACTION(BETA,DELTA);
D:=PYTHADD(TAKEFRACTION(MAJORAXIS,ALPHA),TAKEFRACTION(MINORAXIS,BETA));
END;D:=TAKEFRACTION((D+4)DIV 8,DELTA);
IF ABS(U)>=ABS(V)THEN ALPHA:=ABS(U)DIV 32768 ELSE ALPHA:=ABS(V)DIV 32768
;IF D<ALPHA THEN D:=ALPHA{:466};DELTA:=C-D;
IF DELTA>0 THEN BEGIN IF DELTA>LEFTLENGTH(R)THEN DELTA:=LEFTLENGTH(R);
IF DELTA>=LEFTLENGTH(Q)THEN{467:}BEGIN DELTA:=LEFTLENGTH(Q);
RIGHTCLASS(P):=C-DELTA;RIGHTU(P):=U;
IF LEFTLENGTH(R)>DELTA THEN BEGIN LEFTV(Q):=V;
MEM[Q+1].INT:=MEM[Q+1].INT-DELTA*LEFTV(R);
MEM[Q+2].INT:=MEM[Q+2].INT+DELTA*RIGHTU(Q);
LEFTLENGTH(R):=LEFTLENGTH(R)-DELTA;END ELSE{469:}BEGIN MEM[P].HH.RH:=R;
LEFTV(R):=V;LEFTLENGTH(R):=DELTA;FREENODE(Q,7);P:=R;END{:469};END{:467}
ELSE IF DELTA=LEFTLENGTH(R)THEN{468:}BEGIN RIGHTCLASS(Q):=C-DELTA;
RIGHTU(Q):=U;LEFTV(R):=V;MEM[Q+1].INT:=MEM[Q+1].INT+DELTA*LEFTV(Q);
MEM[Q+2].INT:=MEM[Q+2].INT-DELTA*RIGHTU(P);
LEFTLENGTH(Q):=LEFTLENGTH(Q)-DELTA;P:=R;END{:468}ELSE{470:}
BEGIN S:=GETNODE(7);MEM[P].HH.RH:=S;MEM[S].HH.RH:=Q;
MEM[S+1].INT:=MEM[Q+1].INT+DELTA*LEFTV(Q);
MEM[S+2].INT:=MEM[Q+2].INT-DELTA*RIGHTU(P);
MEM[Q+1].INT:=MEM[Q+1].INT-DELTA*LEFTV(R);
MEM[Q+2].INT:=MEM[Q+2].INT+DELTA*RIGHTU(Q);LEFTV(S):=LEFTV(Q);
RIGHTU(S):=U;LEFTV(Q):=V;RIGHTCLASS(S):=C-DELTA;
LEFTLENGTH(P):=LEFTLENGTH(P)-DELTA;LEFTLENGTH(S):=DELTA;
LEFTLENGTH(Q):=LEFTLENGTH(Q)-DELTA;END{:470};END ELSE P:=Q;
Q:=MEM[P].HH.RH;R:=MEM[Q].HH.RH;UNTIL(Q=0)OR(R=0){:465};{471:}
IF Q<>0 THEN BEGIN IF RIGHTU(H)=0 THEN BEGIN P:=H;H:=MEM[H].HH.RH;
FREENODE(P,7);MEM[Q+1].INT:=-MEM[H+1].INT;END;P:=Q;END ELSE Q:=P;
R:=MEM[H].HH.RH;REPEAT S:=GETNODE(7);MEM[P].HH.RH:=S;P:=S;
MEM[P+1].INT:=-MEM[R+1].INT;MEM[P+2].INT:=-MEM[R+2].INT;R:=MEM[R].HH.RH;
UNTIL R=Q;MEM[P].HH.RH:=H{:471};MAKEELLIPSE:=H;END;{:462}{472:}
FUNCTION INITSCREEN:BOOLEAN;BEGIN INITSCREEN:=FALSE;END;
PROCEDURE UPDATESCREEN;BEGIN CONFUSION(117);END;{:472}{475:}
PROCEDURE BLANKRECTANG(LEFTCOL,RIGHTCOL:SCREENCOL;
TOPROW,BOTROW:SCREENROW);VAR R:SCREENROW;C:SCREENCOL;
BEGIN{FOR R:=TOPROW TO BOTROW-1 DO FOR C:=LEFTCOL TO RIGHTCOL-1 DO
SCREENPIXEL[R,C]:=0;}CONFUSION(98);END;{:475}{476:}
PROCEDURE PAINTROW(R:SCREENROW;B:PIXELCOLOR;VAR A:TRANSSPEC;
N:SCREENCOL);VAR K:SCREENCOL;C:SCREENCOL;BEGIN{K:=0;C:=A[0];
REPEAT K:=K+1;REPEAT SCREENPIXEL[R,C]:=B;C:=C+1;UNTIL C=A[K];B:=1-B;
UNTIL K=N;}CONFUSION(112);END;{:476}{482:}PROCEDURE 47(K:WINDOWNUMBER;
R0,C0,R1,C1:INTEGER;X,Y:SCALED);BEGIN{483:}IF R0<0 THEN R0:=0;
IF R1>SCREENDEPTH THEN R1:=SCREENDEPTH;
IF R1<R0 THEN IF R0>SCREENDEPTH THEN R0:=R1 ELSE R1:=R0;
IF C0<0 THEN C0:=0;IF C1>SCREENWIDTH THEN C1:=SCREENWIDTH;
IF C1<C0 THEN IF C0>SCREENWIDTH THEN C0:=C1 ELSE C1:=C0{:483};
WINDOWOPEN[K]:=TRUE;WINDOWTIME[K]:=WINDOWTIME[K]+1;LEFTCOL[K]:=C0;
RIGHTCOL[K]:=C1;TOPROW[K]:=R0;BOTROW[K]:=R1;{484:}M:=ROUNDTRUNC(X);
N:=ROUNDTRUNC(Y)-1;MWINDOW[K]:=C0-M;NWINDOW[K]:=R0+N{:484};
BEGIN IF NOT SCREENSTARTE THEN SCREENOK:=INITSCREEN;END;
IF SCREENOK THEN BEGIN BLANKRECTANG(C0,C1,R0,R1);UPDATESCREEN;END;END;
{:482}{485:}PROCEDURE DISPEDGES(K:WINDOWNUMBER;H:HALFWORD);LABEL 30,40;
VAR P,Q:HALFWORD;ALREADYTHERE:BOOLEAN;R:INTEGER;{488:}N:SCREENCOL;
W,WW:INTEGER;B:PIXELCOLOR;M:INTEGER;Z:INTEGER;MADJUSTMENT:INTEGER;
RIGHTEDGE:INTEGER;MINCOL:SCREENCOL;{:488}
BEGIN IF SCREENOK THEN IF LEFTCOL[K]<RIGHTCOL[K]THEN IF TOPROW[K]<BOTROW
[K]THEN BEGIN ALREADYTHERE:=FALSE;
IF MEM[H+3].HH.RH=K THEN IF MEM[H+4].INT=WINDOWTIME[K]THEN ALREADYTHERE
:=TRUE;
IF NOT ALREADYTHERE THEN BLANKRECTANG(LEFTCOL[K],RIGHTCOL[K],TOPROW[K],
BOTROW[K]);{489:}MADJUSTMENT:=MWINDOW[K]-MEM[H+3].HH.LH;
RIGHTEDGE:=8*(RIGHTCOL[K]-1-MADJUSTMENT)+7;MINCOL:=LEFTCOL[K]{:489};
P:=MEM[H].HH.RH;R:=NWINDOW[K]-(MEM[H+1].HH.LH-4096);
WHILE(P<>H)AND(R>=TOPROW[K])DO BEGIN IF R<BOTROW[K]THEN{486:}
BEGIN IF MEM[P+1].HH.LH>1 THEN SORTEDGES(P)ELSE IF MEM[P+1].HH.LH=1 THEN
IF ALREADYTHERE THEN GOTO 30;MEM[P+1].HH.LH:=1;{490:}N:=0;W:=0;
Q:=MEM[P+1].HH.RH;ROWTRANSITIO[0]:=MINCOL;
WHILE Q>13000 DO BEGIN Z:=MEM[Q].HH.LH-0;IF Z>RIGHTEDGE THEN GOTO 40;
M:=(Z DIV 8)+MADJUSTMENT;WW:=W+(Z MOD 8)-4;
IF W<=0 THEN BEGIN IF WW>0 THEN IF M>=MINCOL THEN{491:}
IF M>ROWTRANSITIO[N]THEN BEGIN IF N=0 THEN B:=0;N:=N+1;
ROWTRANSITIO[N]:=M;END ELSE IF N>0 THEN N:=N-1{:491};
END ELSE IF WW<=0 THEN IF M>=MINCOL THEN{492:}
IF M>ROWTRANSITIO[N]THEN BEGIN IF N=0 THEN B:=1;N:=N+1;
ROWTRANSITIO[N]:=M;END ELSE IF N>0 THEN N:=N-1{:492};W:=WW;
Q:=MEM[Q].HH.RH;END;40:{493:}
IF N=0 THEN IF W>0 THEN B:=1 ELSE IF ALREADYTHERE THEN B:=0 ELSE GOTO 30
;N:=N+1;ROWTRANSITIO[N]:=RIGHTCOL[K]{:493};{:490};
PAINTROW(R,B,ROWTRANSITIO,N);30:END{:486};P:=MEM[P].HH.RH;R:=R-1;END;
UPDATESCREEN;WINDOWTIME[K]:=WINDOWTIME[K]+1;MEM[H+3].HH.RH:=K;
MEM[H+4].INT:=WINDOWTIME[K];END;END;{:485}{496:}
PROCEDURE SHOWCMDMOD(CMD,MOD);BEGIN BEGINDIAGNOS;PRINTNL(123);
PRINTCMDMOD(CMD,MOD);PRINTCHAR(125);ENDDIAGNOSTI(FALSE);END;{:496}{505:}
PROCEDURE SHOWCONTEXT;LABEL 30;VAR OLDSETTING:0..5;{510:}I:0..BUFSIZE;
J:0..BUFSIZE;L:0..HALFERRORLIN;M:INTEGER;N:0..ERRORLINE;P:INTEGER;
Q:INTEGER;{:510}BEGIN BASEPTR:=INPUTPTR;INPUTSTACK[BASEPTR]:=CURINPUT;
WHILE TRUE DO BEGIN CURINPUT:=INPUTSTACK[BASEPTR];{506:}
IF(BASEPTR=INPUTPTR)OR(CURINPUT.INDEXFIELD<=MAXINOPEN)OR(CURINPUT.
INDEXFIELD<>MAXINOPEN+5)OR(CURINPUT.LOCFIELD<>0)THEN BEGIN TALLY:=0;
OLDSETTING:=SELECTOR;IF(CURINPUT.INDEXFIELD<=MAXINOPEN)THEN BEGIN{507:}
IF(CURINPUT.NAMEFIELD=0)THEN IF BASEPTR=0 THEN PRINTNL(416)ELSE PRINTNL(
417)ELSE BEGIN PRINTNL(418);PRINTINT(LINE);END;PRINTCHAR(32){:507};
{513:}BEGIN L:=TALLY;TALLY:=0;SELECTOR:=4;TRICKCOUNT:=1000000;END;
IF CURINPUT.LIMITFIELD>0 THEN FOR I:=CURINPUT.STARTFIELD TO CURINPUT.
LIMITFIELD-1 DO BEGIN IF I=CURINPUT.LOCFIELD THEN BEGIN FIRSTCOUNT:=
TALLY;TRICKCOUNT:=TALLY+1+ERRORLINE-HALFERRORLIN;
IF TRICKCOUNT<ERRORLINE THEN TRICKCOUNT:=ERRORLINE;END;PRINT(BUFFER[I]);
END{:513};END ELSE BEGIN{508:}
CASE CURINPUT.INDEXFIELD OF MAXINOPEN+1:PRINTNL(419);
MAXINOPEN+5:IF CURINPUT.LOCFIELD=0 THEN PRINTNL(420)ELSE PRINTNL(421);
MAXINOPEN+6:PRINTNL(422);WHILELOOP:PRINTNL(423);
MAXINOPEN+3:PRINTNL(424);MAXINOPEN+4:PRINTNL(425);
MAXINOPEN+7:BEGIN PRINTLN;
IF CURINPUT.NAMEFIELD<>0 THEN PRINT(HASH[CURINPUT.NAMEFIELD].RH)ELSE{509
:}BEGIN P:=PARAMSTACK[CURINPUT.LIMITFIELD];
IF P=0 THEN SHOWTOKENLIS(PARAMSTACK[CURINPUT.LIMITFIELD+1],0,1000)ELSE
BEGIN Q:=P;WHILE MEM[Q].HH.RH<>0 DO Q:=MEM[Q].HH.RH;
MEM[Q].HH.RH:=PARAMSTACK[CURINPUT.LIMITFIELD+1];SHOWTOKENLIS(P,0,1000);
MEM[Q].HH.RH:=0;END;END{:509};END;MAXINOPEN+8:PRINTNL(426);
OTHERS:PRINTNL(63)END{:508};{514:}BEGIN L:=TALLY;TALLY:=0;SELECTOR:=4;
TRICKCOUNT:=1000000;END;
IF CURINPUT.INDEXFIELD<>MAXINOPEN+7 THEN SHOWTOKENLIS(CURINPUT.
STARTFIELD,CURINPUT.LOCFIELD,100000)ELSE SHOWTOKENLIS(MEM[CURINPUT.
STARTFIELD].HH.RH,CURINPUT.LOCFIELD,100000){:514};END;
SELECTOR:=OLDSETTING;{512:}
IF TRICKCOUNT=1000000 THEN BEGIN FIRSTCOUNT:=TALLY;
TRICKCOUNT:=TALLY+1+ERRORLINE-HALFERRORLIN;
IF TRICKCOUNT<ERRORLINE THEN TRICKCOUNT:=ERRORLINE;END;
IF TALLY<TRICKCOUNT THEN M:=TALLY-FIRSTCOUNT ELSE M:=TRICKCOUNT-
FIRSTCOUNT;IF L+FIRSTCOUNT<=HALFERRORLIN THEN BEGIN P:=0;
N:=L+FIRSTCOUNT;END ELSE BEGIN PRINT(148);
P:=L+FIRSTCOUNT-HALFERRORLIN+3;N:=HALFERRORLIN;END;
FOR Q:=P TO FIRSTCOUNT-1 DO PRINTCHAR(TRICKBUF[Q MOD ERRORLINE]);
PRINTLN;FOR Q:=1 TO N DO PRINTCHAR(32);
IF M+N<=ERRORLINE THEN P:=FIRSTCOUNT+M ELSE P:=FIRSTCOUNT+(ERRORLINE-N-3
);FOR Q:=FIRSTCOUNT TO P-1 DO PRINTCHAR(TRICKBUF[Q MOD ERRORLINE]);
IF M+N>ERRORLINE THEN PRINT(148){:512};END{:506};
IF(CURINPUT.INDEXFIELD<=MAXINOPEN)THEN IF(CURINPUT.NAMEFIELD>0)OR(
BASEPTR=0)THEN GOTO 30;BASEPTR:=BASEPTR-1;END;
30:CURINPUT:=INPUTSTACK[INPUTPTR];END;{:505}{518:}
PROCEDURE BEGINTOKENLI(P:HALFWORD;T:QUARTERWORD);
BEGIN BEGIN IF INPUTPTR>MAXINSTACK THEN BEGIN MAXINSTACK:=INPUTPTR;
IF INPUTPTR=STACKSIZE THEN OVERFLOW(427,STACKSIZE);END;
INPUTSTACK[INPUTPTR]:=CURINPUT;INPUTPTR:=INPUTPTR+1;END;
CURINPUT.STARTFIELD:=P;CURINPUT.INDEXFIELD:=T;
IF T=MAXINOPEN+7 THEN BEGIN ADDTOKENREF(P);
CURINPUT.LIMITFIELD:=PARAMPTR;END ELSE CURINPUT.LOCFIELD:=P;END;{:518}
{519:}PROCEDURE ENDTOKENLIST;VAR P:HALFWORD;
BEGIN IF CURINPUT.INDEXFIELD>=MAXINOPEN+5 THEN BEGIN IF CURINPUT.
INDEXFIELD<=MAXINOPEN+6 THEN FLUSHLIST(CURINPUT.STARTFIELD)ELSE BEGIN
DELETETOKENR(CURINPUT.STARTFIELD);
WHILE PARAMPTR>CURINPUT.LIMITFIELD DO BEGIN PARAMPTR:=PARAMPTR-1;
P:=PARAMSTACK[PARAMPTR];IF MEM[P].HH.RH=1 THEN BEGIN RECYCLEVALUE(P);
FREENODE(P,2);END ELSE FLUSHLIST(P);END;END;END;
BEGIN INPUTPTR:=INPUTPTR-1;CURINPUT:=INPUTSTACK[INPUTPTR];END;
BEGIN IF INTERRUPT<>0 THEN PAUSEFORINST;END;END;{:519}{520:}
FUNCTION CURTOK:HALFWORD;BEGIN IF CURSYM=0 THEN BEGIN P:=GETNODE(2);
MEM[P+1].INT:=CURMOD;MEM[P].HH.LH:=CURCMD;END ELSE BEGIN P:=GETAVAIL;
MEM[P].HH.LH:=CURSYM;END;END;{:520}{521:}PROCEDURE BACKINPUT;
VAR P:HALFWORD;
BEGIN WHILE(CURINPUT.INDEXFIELD>MAXINOPEN)AND(CURINPUT.LOCFIELD=0)DO
ENDTOKENLIST;P:=CURTOK;BEGINTOKENLI(P,MAXINOPEN+5);END;{:521}{522:}
PROCEDURE BACKERROR;BEGIN OKTOINTERRUP:=FALSE;BACKINPUT;
OKTOINTERRUP:=TRUE;ERROR;END;PROCEDURE INSERROR;
BEGIN OKTOINTERRUP:=FALSE;BACKINPUT;CURINPUT.INDEXFIELD:=MAXINOPEN+6;
OKTOINTERRUP:=TRUE;ERROR;END;{:522}{523:}PROCEDURE BEGINFILEREA;
BEGIN IF INOPEN=MAXINOPEN THEN OVERFLOW(428,MAXINOPEN);
IF FIRST=BUFSIZE THEN OVERFLOW(128,BUFSIZE);INOPEN:=INOPEN+1;
BEGIN IF INPUTPTR>MAXINSTACK THEN BEGIN MAXINSTACK:=INPUTPTR;
IF INPUTPTR=STACKSIZE THEN OVERFLOW(427,STACKSIZE);END;
INPUTSTACK[INPUTPTR]:=CURINPUT;INPUTPTR:=INPUTPTR+1;END;
CURINPUT.INDEXFIELD:=INOPEN;LINESTACK[CURINPUT.INDEXFIELD]:=LINE;
CURINPUT.STARTFIELD:=FIRST;STATE:=MIDLINE;CURINPUT.NAMEFIELD:=0;END;
{:523}{524:}PROCEDURE ENDFILEREADI;BEGIN FIRST:=CURINPUT.STARTFIELD;
LINE:=LINESTACK[CURINPUT.INDEXFIELD];
IF CURINPUT.NAMEFIELD>1 THEN ACLOSE(INPUTFILE[CURINPUT.INDEXFIELD]);
BEGIN INPUTPTR:=INPUTPTR-1;CURINPUT:=INPUTSTACK[INPUTPTR];END;
INOPEN:=INOPEN-1;END;{:524}{525:}PROCEDURE CLEARFORERRO;
BEGIN WHILE(CURINPUT.INDEXFIELD<=MAXINOPEN)AND(CURINPUT.NAMEFIELD=0)AND(
INPUTPTR>0)AND(CURINPUT.LOCFIELD=CURINPUT.LIMITFIELD)DO ENDFILEREADI;
PRINTLN;BREAKIN(TERMIN,TRUE);END;{:525}{528:}PROCEDURE CHECKOUTERVA;
VAR P:HALFWORD;Q:HALFWORD;BEGIN IF SCANNERSTATU<>NORMAL THEN BEGIN{529:}
IF CURSYM<>0 THEN BEGIN P:=GETAVAIL;MEM[P].HH.LH:=CURSYM;
BEGINTOKENLI(P,MAXINOPEN+5);CURCMD:=6;CURSYM:=2097;END{:529};
IF SCANNERSTATU>SKIPPING THEN{530:}BEGIN RUNAWAY;
IF CURSYM=0 THEN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(435);
END ELSE BEGIN CURSYM:=0;BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(436);END;END;PRINT(437);SPRINTCS(WARNINGINDEX);P:=GETAVAIL;
MEM[P].HH.LH:=2098;BEGINTOKENLI(P,MAXINOPEN+6);BEGIN HELPPTR:=4;
HELPLINE[3]:=438;HELPLINE[2]:=439;HELPLINE[1]:=440;HELPLINE[0]:=441;END;
DELETIONSALL:=FALSE;ERROR;DELETIONSALL:=TRUE;END{:530}
ELSE BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(429);END;
PRINT(430);PRINTINT(SKIPLINE);BEGIN HELPPTR:=3;HELPLINE[2]:=431;
HELPLINE[1]:=432;HELPLINE[0]:=433;END;IF CURSYM=0 THEN HELPLINE[2]:=434;
CURSYM:=2099;INSERROR;END;END;END;{:528}{532:}PROCEDURE FIRMUPTHELIN;
FORWARD;{:532}{533:}PROCEDURE GETNEXT;LABEL 20,10,40,85,86,87;
VAR K:0..BUFSIZE;BEGIN 20:CURSYM:=0;
IF(CURINPUT.INDEXFIELD<=MAXINOPEN)THEN{535:}
BEGIN 25:C:=BUFFER[CURINPUT.LOCFIELD];
CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;CLASS:=CHARCLASS[C];
CASE CLASS OF 0:GOTO 85;
1:BEGIN CLASS:=CHARCLASS[BUFFER[CURINPUT.LOCFIELD]];
IF CLASS>1 THEN GOTO 25 ELSE IF CLASS=1 THEN BEGIN N:=0;GOTO 86;END;
2:GOTO 25;3:BEGIN{544:}IF CURINPUT.NAMEFIELD>1 THEN{546:}
BEGIN LINE:=LINE+1;FIRST:=CURINPUT.STARTFIELD;
IF NOT FORCEEOF THEN BEGIN IF INPUTLN(INPUTFILE[CURINPUT.INDEXFIELD],
TRUE)THEN FIRMUPTHELIN ELSE FORCEEOF:=TRUE;END;
IF FORCEEOF THEN BEGIN PRINTCHAR(41);FORCEEOF:=FALSE;BREAK(TERMOUT);
ENDFILEREADI;CHECKOUTERVA;GOTO 20;END;
BUFFER[CURINPUT.LIMITFIELD]:=37 FIRST:=CURINPUT.LIMITFIELD+1;
CURINPUT.LOCFIELD:=CURINPUT.STARTFIELD;END{:546}
ELSE BEGIN IF NOT(CURINPUT.NAMEFIELD=0)THEN BEGIN CURCMD:=48;CURMOD:=0;
GOTO 10;END;IF INPUTPTR>0 THEN BEGIN ENDFILEREADI;GOTO 20;END;
IF SELECTOR<2 THEN OPENLOGFILE;
IF INTERACTION>1 THEN BEGIN IF CURINPUT.LIMITFIELD=CURINPUT.STARTFIELD
THEN PRINTNL(449);PRINTLN;FIRST:=CURINPUT.STARTFIELD;BEGIN;PRINT(42);
TERMINPUT;END;CURINPUT.LIMITFIELD:=LAST;BUFFER[CURINPUT.LIMITFIELD]:=37;
FIRST:=CURINPUT.LIMITFIELD+1;CURINPUT.LOCFIELD:=CURINPUT.STARTFIELD;
END ELSE FATALERROR(450);END{:544};
BEGIN IF INTERRUPT<>0 THEN PAUSEFORINST;END;GOTO 25;END;4:{536:}
BEGIN IF BUFFER[CURINPUT.LOCFIELD]=34 THEN CURMOD=300 ELSE BEGIN K:=
CURINPUT.LOCFIELD;BUFFER[CURINPUT.LIMITFIELD+1]:=34;
REPEAT CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;
UNTIL BUFFER[CURINPUT.LOCFIELD]=34;
IF CURINPUT.LOCFIELD>CURINPUT.LIMITFIELD THEN{537:}
BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(442);END;
BEGIN HELPPTR:=3;HELPLINE[2]:=443;HELPLINE[1]:=444;HELPLINE[0]:=445;
END DELETIONSALL:=FALSE;ERROR;DELETIONSALL:=TRUE;GOTO 20;END{:537};
IF CURINPUT.LOCFIELD=K+1 THEN CURMOD:=BUFFER[K]ELSE BEGIN BEGIN IF
POOLPTR+CURINPUT.LOCFIELD-K>POOLSIZE THEN OVERFLOW(129,POOLSIZE-
INITPOOLPTR);END;REPEAT BEGIN STRPOOL[POOLPTR]:=BUFFER[K];
POOLPTR:=POOLPTR+1;END;K:=K+1;UNTIL K=CURINPUT.LOCFIELD;
CURMOD:=MAKESTRING;END;END;CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;
CURCMD:=12;GOTO 10;END{:536};5,6,7,8:BEGIN K:=CURINPUT.LOCFIELD-1;
GOTO 40;END;OTHERS:END;K:=CURINPUT.LOCFIELD-1;
WHILE CHARCLASS[BUFFER[CURINPUT.LOCFIELD]]=CLASS DO CURINPUT.LOCFIELD:=
CURINPUT.LOCFIELD+1;GOTO 40;85:{538:}N=C-48;
WHILE CHARCLASS[BUFFER[CURINPUT.LOCFIELD]]=0 DO BEGIN IF N<4096 THEN N:=
10*N+BUFFER[CURINPUT.LOCFIELD]-48;
CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;END;
IF(BUFFER[CURINPUT.LOCFIELD]<>46)OR(CHARCLASS[BUFFER[CURINPUT.LOCFIELD+1
]]<>0)DO BEGIN F:=0;GOTO 87;
END ELSE CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1{:538};86:{539:}K:=0;
REPEAT IF K<17 THEN BEGIN DIG[K]:=BUFFER[CURINPUT.LOCFIELD]-48;K:=K+1;
END;CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;
UNTIL CHARCLASS[BUFFER[CURINPUT.LOCFIELD]]<>0;F:=ROUNDDECIMAL(K){:539};
87:{540:}
IF N<4096 THEN CURMODE:=N*65536+F ELSE BEGIN BEGIN IF INTERACTION=3 THEN
;PRINTNL(133);PRINT(446);END;BEGIN HELPPTR:=2;HELPLINE[1]:=447;
HELPLINE[0]:=448;END;DELETIONSALL:=FALSE;ERROR;DELETIONSALL:=TRUE;
CURMOD:=268435455;END;CURCMD:=11;GOTO 10{:540};
40:CURSYM:=IDLOOKUP(K,CURINPUT.LOCFIELD-K);END{:535}ELSE{541:}
IF CURINPUT.LOCFIELD>13000 THEN BEGIN CURSYM:=MEM[CURINPUT.LOCFIELD].HH.
LH;CURINPUT.LOCFIELD:=MEM[CURINPUT.LOCFIELD].HH.RH;
IF CURSYM>=2101 THEN IF CURSYM>=2101+PARAMSIZE THEN{542:}
BEGIN IF CURSYM>=2101+PARAMSIZE+PARAMSIZE THEN CURSYM:=CURSYM-PARAMSIZE;
BEGINTOKENLI(PARAMSTACK[CURINPUT.LIMITFIELD+CURSYM-(2101+PARAMSIZE)],
MAXINOPEN+1);GOTO 20;END{:542}ELSE BEGIN CURCMD:=EXPRPARAM;
CURMOD:=PARAMSTACK[CURINPUT.LIMITFIELD+CURSYM-(2102)];GOTO 10;END;
END ELSE IF CURINPUT.LOCFIELD>0 THEN{543:}
BEGIN CURCMD:=MEM[CURINPUT.LOCFIELD].HH.LH;
CURMOD:=MEM[CURINPUT.LOCFIELD+1].INT;CURSYM:=0;END{:543}
ELSE BEGIN ENDTOKENLIST;GOTO 20;END{:541};{534:}CURCMD:=EQTB[CURSYM].LH;
CURMOD:=EQTB[CURSYM].RH;IF CURCMD>=OUTERTAG THEN BEGIN CHECKOUTERVA;
IF CURCMD>=OUTERTAG THEN CURCMD:=CURCMD-OUTERTAG;END{:534};10:END;{:533}
{547:}PROCEDURE FIRMUPTHELIN;VAR K:0..BUFSIZE;
BEGIN CURINPUT.LIMITFIELD:=LAST;
IF(INTERNAL[24]>0)AND(INTERACTION>1)THEN BEGIN PRINTLN;;
IF CURINPUT.STARTFIELD<CURINPUT.LIMITFIELD THEN FOR K:=CURINPUT.
STARTFIELD TO CURINPUT.LIMITFIELD-1 DO PRINT(BUFFER[K]);
FIRST:=CURINPUT.LIMITFIELD;BEGIN;PRINT(451);TERMINPUT;END;
IF LAST>FIRST THEN BEGIN FOR K:=FIRST TO LAST-1 DO BUFFER[K+CURINPUT.
STARTFIELD-FIRST]:=BUFFER[K];
CURINPUT.LIMITFIELD:=CURINPUT.STARTFIELD+LAST-FIRST;END;END;END;{:547}
{550:}FUNCTION SCANTOKS(TERMINATOR:QUARTERWORD;
SUBSTLIST,TAILEND:HALFWORD;SUFFIXCOUNT:SMALLNUMBER):HALFWORD;
LABEL 30,40;VAR P:HALFWORD;Q:HALFWORD;BALANCE:INTEGER;BEGIN P:=13001;
BALANCE:=1;MEM[13001].HH.RH:=0;WHILE TRUE DO BEGIN GETNEXT;
IF CURCMD=TERMINATOR THEN{552:}
IF CURMOD>0 THEN BALANCE:=BALANCE+1 ELSE BEGIN BALANCE:=BALANCE-1;
IF BALANCE=0 THEN GOTO 30;END{:552}
ELSE IF CURCMD=MACROSPECIAL THEN{555:}
BEGIN IF CURMOD=0 THEN GETNEXT ELSE IF CURMOD<=SUFFIXCOUNT THEN CURSYM:=
2101+PARAMSIZE-1+CURMOD;END{:555}ELSE IF CURSYM>0 THEN{551:}
BEGIN Q:=SUBSTLIST;
WHILE Q<>0 DO BEGIN IF MEM[Q].HH.LH=CURSYM THEN BEGIN CURSYM:=MEM[Q+1].
INT;GOTO 40;END;Q:=MEM[Q].HH.RH;END;40:END{:551};
IF CURSYM>0 THEN BEGIN Q:=GETAVAIL;MEM[Q].HH.LH:=CURSYM;
END ELSE BEGIN Q:=GETNODE(2);MEM[Q+1].INT:=CURMOD;MEM[Q].HH.LH:=CURCMD;
END;MEM[P].HH.RH:=Q;P:=Q;END;30:MEM[P].HH.RH:=TAILEND;
FLUSHNODELIS(SUBSTLIST);SCANTOKS:=MEM[13001].HH.RH;END;{:550}{556:}
PROCEDURE SCANLOOP;VAR P:HALFWORD;BEGIN SCANNERSTATU:=LOOPDEFINING;
WARNINGINDEX:=CURSYM;P:=SCANTOKS(4,0,13003,0);SCANNERSTATU:=NORMAL;
SCANLOOP:=P;END;{:556}{558:}PROCEDURE GETCLEARSYMB;BEGIN GETSYMBOL;
IF CURCMD=CURINPUT.NAMEFIELD THEN IF CURMOD<>0 THEN BEGIN FLUSHBELOWVA(
CURMOD);FREENODE(CURMOD,2);END;;END;{:558}{559:}PROCEDURE CHECKEQUALS;
BEGIN IF CURCMD<>25 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(467);END;BEGIN HELPPTR:=5;HELPLINE[4]:=468;HELPLINE[3]:=469;
HELPLINE[2]:=470;HELPLINE[1]:=471;HELPLINE[0]:=472;END;BACKERROR;END;
END{:559}{560:}PROCEDURE MAKEOPDEF;VAR M:3..5;P,Q,R:HALFWORD;
BEGIN M:=CURMOD;GETSYMBOL;P:=GETNODE(2);MEM[P].HH.LH:=CURSYM;
MEM[P+1].INT:=2101;GETCLEARSYMB;WARNINGINDEX:=CURSYM;GETSYMBOL;
Q:=GETNODE(2);MEM[Q].HH.LH:=CURSYM;MEM[Q+1].INT:=2102;MEM[Q].HH.RH:=P;
GETNEXT;CHECKEQUALS;SCANNERSTATU:=OPDEFINING;R:=GETAVAIL;
MEM[R].HH.LH:=0;MEM[R].HH.RH:=SCANTOKS(34,Q,0,0);SCANNERSTATU:=NORMAL;
EQTB[WARNINGINDEX].LH:=OPMACRO-3+M;EQTB[WARNINGINDEX].RH:=R;END;{:560}
{563:}{779:}PROCEDURE CHECKDELIMIT(LDELIM,RDELIM:HALFWORD);LABEL 10;
BEGIN IF CURCMD=54 THEN IF CURMOD=LDELIM THEN GOTO 10;
IF CURSYM<>RDELIM THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(616);END;PRINT(HASH[RDELIM].RH);PRINT(487);BEGIN HELPPTR:=2;
HELPLINE[1]:=617;HELPLINE[0]:=618;END;BACKERROR;
END ELSE BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(619);END;
PRINT(HASH[RDELIM].RH);PRINT(620);BEGIN HELPPTR:=3;HELPLINE[2]:=621;
HELPLINE[1]:=622;HELPLINE[0]:=623;END;ERROR;END;10:END;{:779}
PROCEDURE SCANDEF;VAR M:1..2;N:0..3;K:0..PARAMSIZE;C:0..5;R:HALFWORD;
Q:HALFWORD;P:HALFWORD;BEGIN M:=CURMOD;C:=0;MEM[13001].HH.RH:=0;
Q:=GETAVAIL;MEM[Q].HH.LH:=0;R:=0;{564:}IF M=1 THEN BEGIN GETCLEARSYMB;
WARNINGINDEX:=CURSYM;SCANNERSTATU:=OPDEFINING;N:=0;
EQTB[WARNINGINDEX].LH:=MAXINOPEN+7;EQTB[WARNINGINDEX].RH:=Q;
END ELSE BEGIN P:=SCANDECLARED;
FLUSHVARIABL(EQTB[MEM[P].HH.LH].RH,MEM[P].HH.RH,TRUE);
WARNINGINDEX:=FINDVARIABLE(P);FLUSHLIST(P);SCANNERSTATU:=VARDEFINING;
N:=2;IF CURCMD=MACROSPECIAL THEN IF CURMOD=3 THEN BEGIN N:=3;GETNEXT;
END;MEM[WARNINDEX].HH.B0:=VARMACRO-2+N;MEM[WARNINDEX+1].INT:=Q;END{:564}
;K:=N;IF CURCMD=8 THEN{565:}REPEAT LDELIM:=CURSYM;RDELIM:=CURMOD;
GETNEXT;
IF(CURCMD=PARAMTYPE)AND(CURMOD>=2101)THEN BASE:=CURMOD ELSE BEGIN BEGIN
IF INTERACTION=3 THEN;PRINTNL(133);PRINT(476);END;BEGIN HELPPTR:=1;
HELPLINE[0]:=477;END;BACKERROR;BASE:=2101;END;{566:}
REPEAT MEM[Q].HH.RH:=GETAVAIL;Q:=MEM[Q].HH.RH;MEM[Q].HH.LH:=BASE+K;
GETSYMBOL;P:=GETNODE(2);MEM[P+1].INT:=BASE+K;MEM[P].HH.LH:=CURSYM;
IF K=PARAMSIZE THEN OVERFLOW(478,PARAMSIZE);K:=K+1;MEM[P].HH.RH:=R;R:=P;
GETNEXT;UNTIL CURCMD<>66{:566};CHECKDELIMIT(LDELIM,RDELIM);GETNEXT;
UNTIL CURCMD<>8;{:565}ELSE IF CURCMD=PARAMTYPE THEN IF M=2 THEN{567:}
IF CURMOD<=2101 THEN BEGIN P:=GETNODE(2);MEM[P+1].INT:=2101+N;
IF CURMOD=0 THEN C:=UNARYMACRO ELSE C:=4;GETSYMBOL;MEM[P].HH.LH:=CURSYM;
MEM[P].HH.RH:=R;R:=P;GETNEXT;IF C=4 THEN IF CURCMD=OF THEN BEGIN C:=5;
P:=GETNODE(2);MEM[P+1].INT:=2102+N;FETSYMBOL;MEM[P].HH.LH:=CURSYM;
MEM[P].HH.RH:=R;R:=P;GETNEXT;END;END{:567};CHECKEQUALS;
MEM[Q].HH.RH:=GETAVAIL;Q:=MEM[Q].HH.RH;MEM[Q].HH.LH:=C;
MEM[Q].HH.RH:=SCANTOKS(34,R,0,N);SCANNERSTATU:=NORMAL;END;{:563}{568:}
PROCEDURE READTOKS;VAR M:HALFWORD;P:HALFWORD;BEGIN GETCLEARSYMB;
M:=CURSYM;IF INTERACTION<=1 THEN FATALERROR(479);BEGINFILEREA;
CURINPUT.NAMEFIELD:=1;BEGIN;PRINT(300);TERMINPUT;END;
CURINPUT.LIMITFIELD:=LAST;BUFFER[CURINPUT.LIMITFIELD]:=37;
FIRST:=CURINPUT.LIMITFIELD+1;CURINPUT.LOCFIELD:=CURINPUT.STARTFIELD;
P:=GETAVAIL;MEM[P].HH.LH:=0;MEM[P].HH.RH:=SCANTOKS(48,0,0,0);
EQTB[M].LH:=MAXINOPEN+7;EQTB[M].RH:=P;ENDFILEREADI;END;{:568}{569:}
{575:}{577:}PROCEDURE PRINTMACRONA(A,N:HALFWORD);VAR P,Q:HALFWORD;
BEGIN IF N<>0 THEN PRINT(N)ELSE BEGIN P:=MEM[A].HH.LH;
IF P=0 THEN PRINT(MEM[MEM[A].HH.RH].HH.LH)ELSE BEGIN Q:=P;
WHILE MEM[Q].HH.RH<>0 DO Q:=MEM[Q].HH.RH;
MEM[Q].HH.RH:=MEM[MEM[A].HH.RH].HH.LH;SHOWTOKENLIS(P,0,1000);
MEM[Q].HH.RH:=0;END;END;END;{:577}{673:}{676:}
PROCEDURE PRINTDP(T:SMALLNUMBER;P:HALFWORD;VERBOSE:BOOLEAN);
VAR Q:HALFWORD;BEGIN Q:=MEM[P].HH.RH;
IF(MEM[Q].HH.LH=0)OR VERBOSE THEN PRINTDEPENDE(P,T)ELSE PRINT(536);END;
{:676}PROCEDURE PRINTEXP(P:HALFWORD;VERBOSE:BOOLEAN);
BEGIN IF P=0 THEN BEGIN T:=CURTYPE;V:=CUREXP;
END ELSE BEGIN T:=MEM[P].HH.B0;
IF T<16 THEN V:=MEM[P+1].INT ELSE V:=MEM[P+1].HH.LH;END;{674:}
CASE T OF 1:PRINT(533);2:IF V=1 THEN PRINT(531)ELSE PRINT(532);
3,5,7,10,12:{677:}BEGIN PRINTCHAR(60);PRINTTYPE(T);PRINTCHAR(62);
REPEAT V:=MEM[V+1].INT;UNTIL MEM[V].HH.B1<>11;PRINTNAME(V);END{:677};
4:PRINT(V);6,9,11,13:BEGIN PRINTCHAR(60);PRINTTYPE(T);PRINTCHAR(62);END;
FUTUREPENTYP:PRINT(534);14:{675:}BEGIN IF P=0 THEN V:=MEM[V+1].INT;
PRINTCHAR(40);
IF MEM[V].HH.B0=15 THEN PRINTSCALED(MEM[V+1].INT)ELSE PRINTDP(MEM[V].HH.
B0,MEM[V+1].HH.LH,VERBOSE);PRINTCHAR(44);
IF MEM[V+2].HH.B0=15 THEN PRINTSCALED(MEM[V+3].INT)ELSE PRINTDP(MEM[V+2]
.HH.B0,MEM[V+3].HH.LH,VERBOSE);PRINTCHAR(41);END{:675};
15:PRINTSCALED(V);16,17:PRINTDP(T,V,VERBOSE);
OTHERS:CONFUSION(535)END{:674};END;{:673}{668:}{669:}
PROCEDURE STASHIN(P:HALFWORD);VAR Q:HALFWORD;
BEGIN MEM[P].HH.B0:=CURTYPE;MEM[P+1].INT:=CUREXP;
IF CURTYPE<=17 THEN IF CURTYPE>=16 THEN BEGIN Q:=CUREXP;
WHILE MEM[Q].HH.LH<>0 DO Q:=MEM[Q].HH.RH;MEM[Q].HH.RH:=MEM[13].HH.RH;
MEM[#+1].HH.RH(MEM[13].HH.RH):=Q;MEM[13].HH.RH:=P;MEM[#+1].HH.RH(P):=13;
MEM[P+1].HH.LH:=CUREXP;END;CURTYPE:=1;END;{:669}
FUNCTION STASHCUREXP:HALFWORD;VAR P:HALFWORD;
BEGIN CASE CURTYPE OF 3,5,7,10,12,13,14:P:=CUREXP;
OTHERS:BEGIN P:=GETNODE(2);MEM[P].HH.B1:=11;STASHIN(P);END END;
CURTYPE:=1;MEM[P].HH.RH:=1;STASHCUREXP:=P;END;{:668}{670:}
PROCEDURE UNSTASHCUREX(P:HALFWORD);VAR Q:HALFWORD;
BEGIN CURTYPE:=MEM[P].HH.B0;CASE CURTYPE OF 3,5,7,10,12,13,14:CUREXP:=P;
OTHERS:BEGIN IF(CURTYPE<=17)AND(CURTYPE>=16)THEN BEGIN Q:=MEM[P+1].HH.LH
;WHILE MEM[Q].HH.LH<>0 DO Q:=MEM[Q].HH.RH;
MEM[#+1].HH.RH(MEM[Q].HH.RH):=MEM[#+1].HH.RH(P);
MEM[MEM[#+1].HH.RH(P)].HH.RH:=MEM[Q].HH.RH;CUREXP:=MEM[P+1].HH.LH;END;
ELSE CUREXP:=MEM[P+1].INT;FREENODE(P,2);END END;END;{:670}
PROCEDURE MACROCALL(DEFREF,ARGLIST,MACRONAME:HALFWORD);LABEL 40,30;
VAR R:HALFWORD;P,Q:HALFWORD;N:INTEGER;LDELIM,RDELIM:HALFWORD;
BALANCE:INTEGER;BEGIN R:=MEM[DEFREF].HH.RH;
MEM[DEFREF].HH.LH:=MEM[DEFREF].HH.LH+1;IF INTERNAL[7]>0 THEN{576:}
BEGIN BEGINDIAGNOS;PRINTLN;PRINTMACRONA(ARGLIST,MACRONAME);
SHOWMACRO(DEFREF);IF ARGLIST<>0 THEN BEGIN N:=0;P:=ARGLIST;
REPEAT Q:=MEM[P].HH.LH;
IF MEM[Q].HH.RH=1 THEN PRINTNL(482)ELSE PRINTNL(483);PRINTINT(N);
PRINT(484);
IF MEM[Q].HH.RH=1 THEN PRINTEXP(Q,TRUE)ELSE PRINTTOKENLI(Q,0,1000);
N:=N+1;P:=MEM[P].HH.RH;UNTIL P=0;END;ENDDIAGNOSTI(FALSE);END{:576};
IF ARGLIST=0 THEN N:=0 ELSE{578:}BEGIN N:=1;TAIL:=ARGLIST;
WHILE MEM[TAIL].HH.RH<>0 DO BEGIN N:=N+1;TAIL:=MEM[TAIL].HH.RH;END;
END{:578};{579:}CURCMD:=67;WHILE MEM[R].HH.LH>=2101 DO BEGIN{580:}
IF CURCMD<>66 THEN BEGIN GETXNEXT;
IF CURCMD<>LEFTDELIM THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(491);END;PRINTMACRONA(ARGLIST,MACRONAME);
BEGIN HELPPTR:=3;HELPLINE[2]:=492;HELPLINE[1]:=493;HELPLINE[0]:=494;END;
IF MEM[R].HH.LH>=2101+PARAMSIZE THEN BEGIN CUREXP:=0;CURTYPE:=20;
END ELSE BEGIN CUREXP:=0;CURTYPE:=15;END;BACKERROR;CURCMD:=54;GOTO 40;
END;LDELIM:=CURSYM;RDELIM:=CURMOD;END;{582:}
IF MEM[R].HH.LH>=2101+PARAMSIZE+PARAMSIZE THEN{583:}
BEGIN WARNINGINDEX:=L;SCANNERSTATU:=ABSORBING;P:=13001;BALANCE:=1;
MEM[13001].HH.RH:=0;WHILE TRUE DO BEGIN GETNEXT;
IF CURCMD=54 THEN BEGIN IF CURMOD=L THEN BEGIN BALANCE:=BALANCE-1;
IF BALANCE=0 THEN GOTO 30;END;
END ELSE IF CURCMD=8 THEN IF CURMOD=R THEN BALANCE:=BALANCE+1;
MEM[P].HH.RH:=CURTOK;P:=MEM[P].HH.RH;END;30:CUREXP:=MEM[13001].HH.RH;
CURTYPE:=20;SCANNERSTATU:=NORMAL;END{:583}ELSE BEGIN GETXNEXT;
IF MEM[R].HH.LH>=2101+PARAMSIZE THEN SCANSUFFIX ELSE SCANEXPRESSI;END;
{:582};40:{581:}BEGIN P:=GETAVAIL;
IF CURTYPE=20 THEN MEM[P].HH.LH:=CUREXP ELSE MEM[P].HH.LH:=STASHCUREXP;
IF ARGLIST=0 THEN ARGLIST:=P ELSE MEM[TAIL].HH.RH:=P;TAIL:=P;N:=N+1;
END{:581}{:580};R:=MEM[R].HH.RH;END;
IF CURCMD=66 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(485);END;PRINTMACRONA(ARGLIST,MACRONAME);PRINT(486);
PRINT(HASH[RDELIM].RH);PRINT(487);BEGIN HELPPTR:=3;HELPLINE[2]:=488;
HELPLINE[1]:=489;HELPLINE[0]:=490;END;ERROR;END;
IF MEM[R].HH.LH<>0 THEN{584:}BEGIN GETXNEXT;
CASE MEM[R].HH.LH OF 1:SCANPRIMARY;2:SCANSECONDAR;3:SCANTERTIARY;
4:SCANEXPRESSI;5:BEGIN SCANEXPRESSI;P:=GETAVAIL;
MEM[P].HH.LH:=STASHCUREXP;
IF ARGLIST=0 THEN ARGLIST:=P ELSE MEM[TAIL].HH.RH:=P;TAIL:=P;N:=N+1;
IF CURCMD<>OF THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(495);END;PRINTMACRONA(ARGLIST,MACRONAME);BEGIN HELPPTR:=1;
HELPLINE[0]:=496;END;BACKERROR;END;GETXNEXT;SCANPRIMARY;END;END;{581:}
BEGIN P:=GETAVAIL;
IF CURTYPE=20 THEN MEM[P].HH.LH:=CUREXP ELSE MEM[P].HH.LH:=STASHCUREXP;
IF ARGLIST=0 THEN ARGLIST:=P ELSE MEM[TAIL].HH.RH:=P;TAIL:=P;N:=N+1;
END{:581};END{:584};30:R:=MEM[R].HH.RH{:579};{585:}
WHILE(CURINPUT.INDEXFIELD>MAXINOPEN)AND(CURINPUT.LOCFIELD=0)DO
ENDTOKENLIST;BEGINTOKENLI(DEFREF,MAXINOPEN+7);
CURINPUT.NAMEFIELD:=MACRONAME;CURINPUT.LOCFIELD:=R;
IF N>0 THEN BEGIN IF PARAMPTR+N>MAXPARAMSTAC THEN BEGIN MAXPARAMSTAC:=
PARAMPTR+N;IF MAXPARAMSTAC>PARAMSIZE THEN OVERFLOW(478,PARAMSIZE);END;
P:=ARGLIST;REPEAT PARAMSTACK[PARAMPTR]:=MEM[P].HH.LH;
PARAMPTR:=PARAMPTR+1;P:=MEM[P].HH.RH;UNTIL P=0;FLUSHLIST(ARGLIST);
END{:585};END;{:575}PROCEDURE PASSTEXT;FORWARD;PROCEDURE STARTINPUT;
FORWARD;PROCEDURE CONDITIONAL;FORWARD;PROCEDURE SCANPRIMARY;FORWARD;
PROCEDURE SCANSECONDAR;FORWARD;PROCEDURE SCANTERTIARY;FORWARD;
PROCEDURE SCANEXPRESSI;FORWARD;PROCEDURE SCANSUFFIX;FORWARD;
PROCEDURE SCANTEXT;FORWARD;PROCEDURE GETXNEXT;VAR P:HALFWORD;
SAVEEXP:HALFWORD;BEGIN GETNEXT;
IF CURCMD<6 THEN BEGIN SAVEEXP:=STASHCUREXP;REPEAT{570:}
BEGIN IF INTERNAL[6]>1 THEN IF CURCMD<>5 THEN SHOWCMDMOD(CURCMD,CURMOD);
CASE CURCMD OF 5:MACROCALL(CURMOD,0,CURSYM);2:CONDITIONAL;3:{600:}
IF CURCHR>IFLIMIT THEN IF IFLIMIT=1 THEN BEGIN BACKINPUT;CURSYM:=2094;
BACKINPUT;END ELSE BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(500);END;PRINTCMDMOD(3,CURCHR);BEGIN HELPPTR:=1;HELPLINE[0]:=504;
END;ERROR;END ELSE BEGIN WHILE CURCHR<>2 DO PASSTEXT;{593:}
BEGIN P:=CONDPTR;IFLINE:=MEM[P+1].INT;CURIF:=MEM[P].HH.B1;
IFLIMIT:=MEM[P].HH.B0;CONDPTR:=MEM[P].HH.RH;FREENODE(P,2);END{:593};
END{:600};1:{573:}IF CURMOD>0 THEN FORCEEOF:=TRUE ELSE STARTINPUT{:573};
END;END{:570};GETNEXT;UNTIL CURCMD>=6;UNSTASHCUREX(SAVEEXP);END;END;
{:569}{591:}PROCEDURE PASSTEXT;LABEL 30;VAR L:INTEGER;
SAVESCANNERS:SMALLNUMBER;BEGIN SAVESCANNERS:=SCANNERSTATU;
SCANNERSTATU:=SKIPPING;L:=0;SKIPLINE:=LINE;WHILE TRUE DO BEGIN GETNEXT;
IF CURCMD=3 THEN BEGIN IF L=0 THEN GOTO 30;IF CURCHR=2 THEN L:=L-1;
END ELSE IF CURCMD=2 THEN L:=L+1;END;30:SCANNERSTATU:=SAVESCANNERS;END;
{:591}{594:}PROCEDURE CHANGEIFLIMI(L:SMALLNUMBER;P:HALFWORD);LABEL 10;
VAR Q:HALFWORD;BEGIN IF P=CONDPTR THEN IFLIMIT:=L ELSE BEGIN Q:=CONDPTR;
WHILE TRUE DO BEGIN IF Q=0 THEN CONFUSION(316);
IF MEM[Q].HH.RH=P THEN BEGIN MEM[Q].HH.B0:=L;GOTO 10;END;
Q:=MEM[Q].HH.RH;END;END;10:END;{:594}{595:}PROCEDURE CONDITIONAL;
LABEL 10,50;VAR B:BOOLEAN;R:60..62;M,N:INTEGER;P,Q:HALFWORD;
SAVESCANNERS:SMALLNUMBER;SAVECONDPTR:HALFWORD;THISIF:SMALLNUMBER;
BEGIN{592:}BEGIN P:=GETNODE(2);MEM[P].HH.RH:=CONDPTR;
MEM[P].HH.B0:=IFLIMIT;MEM[P].HH.B1:=CURIF;MEM[P+1].INT:=IFLINE;
CONDPTR:=P;CURIF:=CURCHR;IFLIMIT:=1;IFLINE:=LINE;END{:592};
SAVECONDPTR:=CONDPTR;THISIF:=CURCHR;{598:}FIXTHIS!{:598};
IF 6>1 THEN{599:}BEGIN BEGINDIAGNOS;IF B THEN PRINT(502)ELSE PRINT(503);
ENDDIAGNOSTI(FALSE);END{:599};
IF B THEN BEGIN CHANGEIFLIMI(3,SAVECONDPTR);GOTO 10;END;{597:}
WHILE TRUE DO BEGIN PASSTEXT;
IF CONDPTR=SAVECONDPTR THEN BEGIN IF CURCHR<>ORCODE THEN GOTO 50;
BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(500);END;PRINTESC(251);
BEGIN HELPPTR:=1;HELPLINE[0]:=501;END;ERROR;
END ELSE IF CURCHR=2 THEN{593:}BEGIN P:=CONDPTR;IFLINE:=MEM[P+1].INT;
CURIF:=MEM[P].HH.B1;IFLIMIT:=MEM[P].HH.B0;CONDPTR:=MEM[P].HH.RH;
FREENODE(P,2);END{:593};END{:597};50:IF CURCHR=2 THEN{593:}
BEGIN P:=CONDPTR;IFLINE:=MEM[P+1].INT;CURIF:=MEM[P].HH.B1;
IFLIMIT:=MEM[P].HH.B0;CONDPTR:=MEM[P].HH.RH;FREENODE(P,2);END{:593}
ELSE IFLIMIT:=2;10:END;{:595}{605:}PROCEDURE BEGINNAME;
BEGIN AREADELIMITE:=0;EXTDELIMITER:=0;END;{:605}{606:}
FUNCTION MORENAME(C:ASCIICODE):BOOLEAN;
BEGIN IF C=32 THEN MORENAME:=FALSE ELSE BEGIN IF(C=62)OR(C=58)THEN BEGIN
AREADELIMITE:=POOLPTR;EXTDELIMITER:=0;
END ELSE IF(C=46)AND(EXTDELIMITER=0)THEN EXTDELIMITER:=POOLPTR;
BEGIN IF POOLPTR+1>POOLSIZE THEN OVERFLOW(129,POOLSIZE-INITPOOLPTR);END;
BEGIN STRPOOL[POOLPTR]:=C;POOLPTR:=POOLPTR+1;END;MORENAME:=TRUE;END;END;
{:606}{607:}PROCEDURE ENDNAME;
BEGIN IF STRPTR+3>MAXSTRINGS THEN OVERFLOW(130,MAXSTRINGS-INITSTRPTR);
IF AREADELIMITE=0 THEN CURAREA:=300 ELSE BEGIN CURAREA:=STRPTR;
STRPTR:=STRPTR+1;STRSTART[STRPTR]:=AREADELIMITE+1;END;
IF EXTDELIMITER=0 THEN BEGIN CUREXT:=300;CURNAME:=MAKESTRING;
END ELSE BEGIN CURNAME:=STRPTR;STRPTR:=STRPTR+1;
STRSTART[STRPTR]:=EXTDELIMITER;CUREXT:=MAKESTRING;END;END;{:607}{609:}
PROCEDURE PACKFILENAME(N,A,E:STRNUMBER);VAR K:INTEGER;C:ASCIICODE;
J:POOLPOINTER;BEGIN K:=0;
FOR J:=STRSTART[A]TO STRSTART[A+1]-1 DO BEGIN C:=STRPOOL[J];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
FOR J:=STRSTART[N]TO STRSTART[N+1]-1 DO BEGIN C:=STRPOOL[J];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
FOR J:=STRSTART[E]TO STRSTART[E+1]-1 DO BEGIN C:=STRPOOL[J];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
IF K<=FILENAMESIZE THEN NAMELENGTH:=K ELSE NAMELENGTH:=FILENAMESIZE;
FOR K:=NAMELENGTH+1 TO FILENAMESIZE DO NAMEOFFILE[K]:=' ';END;{:609}
{613:}PROCEDURE PACKBUFFERED(N:SMALLNUMBER;A,B:INTEGER);VAR K:INTEGER;
C:ASCIICODE;J:INTEGER;
BEGIN IF N+B-A+6>FILENAMESIZE THEN B:=A+FILENAMESIZE-N-6;K:=0;
FOR J:=1 TO N DO BEGIN C:=XORD[MFBASEDEFAUL[J]];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
FOR J:=A TO B DO BEGIN C:=BUFFER[J];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
FOR J:=17 TO 21 DO BEGIN C:=XORD[MFBASEDEFAUL[J]];K:=K+1;
IF K<=FILENAMESIZE THEN NAMEOFFILE[K]:=XCHR[C];END;
IF K<=FILENAMESIZE THEN NAMELENGTH:=K ELSE NAMELENGTH:=FILENAMESIZE;
FOR K:=NAMELENGTH+1 TO FILENAMESIZE DO NAMEOFFILE[K]:=' ';END;{:613}
{615:}FUNCTION MAKENAMESTRI:STRNUMBER;VAR K:1..FILENAMESIZE;
BEGIN BEGIN IF POOLPTR+NAMELENGTH>POOLSIZE THEN OVERFLOW(129,POOLSIZE-
INITPOOLPTR);END;
FOR K:=1 TO NAMELENGTH DO BEGIN STRPOOL[POOLPTR]:=XORD[NAMEOFFILE[K]];
POOLPTR:=POOLPTR+1;END;MAKENAMESTRI:=MAKESTRING;END;
FUNCTION AMAKENAMESTR(VAR F:ALPHAFILE):STRNUMBER;
BEGIN AMAKENAMESTR:=MAKENAMESTRI;END;
FUNCTION BMAKENAMESTR(VAR F:BYTEFILE):STRNUMBER;
BEGIN BMAKENAMESTR:=MAKENAMESTRI;END;
FUNCTION WMAKENAMESTR(VAR F:WORDFILE):STRNUMBER;
BEGIN WMAKENAMESTR:=MAKENAMESTRI;END;{:615}{616:}PROCEDURE SCANFILENAME;
LABEL 30;BEGIN BEGINNAME;
WHILE BUFFER[CURINPUT.LOCFIELD]=32 DO CURINPUT.LOCFIELD:=CURINPUT.
LOCFIELD+1;
WHILE TRUE DO BEGIN IF CURINPUT.LOCFIELD=CURINPUT.LIMITFIELD THEN GOTO
30;IF NOT MORENAME(BUFFER[CURINPUT.LOCFIELD])THEN GOTO 30;
CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;END;30:ENDNAME;END;{:616}{619:}
PROCEDURE PACKJOBNAME(S:STRNUMBER);BEGIN CURAREA:=300;CUREXT:=S;
CURNAME:=JOBNAME;PACKFILENAME(CURNAME,CURAREA,CUREXT);END;{:619}{620:}
PROCEDURE PROMPTFILENA(S,E:STRNUMBER);LABEL 30;VAR K:0..BUFSIZE;
BEGIN IF INTERACTION=2 THEN;IF S=506 THEN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(507);END ELSE BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(508);END;PRINTFILENAM(CURNAME,CURAREA,CUREXT);
PRINT(509);IF E=510 THEN SHOWCONTEXT;PRINTNL(511);PRINT(S);
IF INTERACTION<2 THEN FATALERROR(512);BREAKIN(TERMIN,TRUE);BEGIN;
PRINT(513);TERMINPUT;END;{621:}BEGIN BEGINNAME;K:=FIRST;
WHILE(BUFFER[K]=32)AND(K<LAST)DO K:=K+1;
WHILE TRUE DO BEGIN IF K=LAST THEN GOTO 30;
IF NOT MORENAME(BUFFER[K])THEN GOTO 30;K:=K+1;END;30:ENDNAME;END{:621};
IF CUREXT=300 THEN CUREXT:=E;PACKFILENAME(CURNAME,CURAREA,CUREXT);END;
{:620}{624:}PROCEDURE OPENLOGFILE;VAR OLDSETTING:0..5;K:0..BUFSIZE;
L:0..BUFSIZE;M:INTEGER;MONTHS:PACKED ARRAY[1..36]OF CHAR;
BEGIN OLDSETTING:=SELECTOR;IF JOBNAME=0 THEN JOBNAME:=516;
PACKJOBNAME(517);WHILE NOT AOPENOUT(LOGFILE)DO{625:}
BEGIN IF INTERACTION<2 THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(508);END;PRINTFILENAM(CURNAME,CURAREA,CUREXT);
PRINT(509);JOBNAME:=0;HISTORY:=3;JUMPOUT;END;PROMPTFILENA(519,517);
END{:625};LOGNAME:=AMAKENAMESTR(LOGFILE);SELECTOR:=2;{626:}
BEGIN WRITE(LOGFILE,'This is METAFONT, Version -100.0');
PRINT(BASEIDENT);PRINT(520);PRINTINT(ROUNDUNSCALE(INTERNAL[13]));
PRINTCHAR(32);MONTHS:='JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC';
M:=ROUNDUNSCALE(INTERNAL[12]);
FOR K:=3*M-2 TO 3*M DO WRITE(LOGFILE,MONTHS[K]);PRINTCHAR(32);
PRINTINT(ROUNDUNSCALE(INTERNAL[11]));PRINTCHAR(32);
M:=ROUNDUNSCALE(INTERNAL[14]);PRINTDD(M DIV 60);PRINTCHAR(58);
PRINTDD(M MOD 60);END{:626};INPUTSTACK[INPUTPTR]:=CURINPUT;PRINTNL(518);
L:=INPUTSTACK[0].LIMITFIELD-1;FOR K:=1 TO L DO PRINT(BUFFER[K]);PRINTLN;
SELECTOR:=OLDSETTING+2;END;{:624}{627:}PROCEDURE STARTINPUT;LABEL 30;
BEGIN SCANFILENAME;IF CUREXT=300 THEN CUREXT:=510;
PACKFILENAME(CURNAME,CURAREA,CUREXT);WHILE TRUE DO BEGIN BEGINFILEREA;
IF AOPENIN(INPUTFILE[CURINPUT.INDEXFIELD])THEN GOTO 30;
PACKFILENAME(CURNAME,505,CUREXT);
IF AOPENIN(INPUTFILE[CURINPUT.INDEXFIELD])THEN GOTO 30;ENDFILEREADI;
PROMPTFILENA(506,510);END;
30:CURINPUT.NAMEFIELD:=AMAKENAMESTR(INPUTFILE[CURINPUT.INDEXFIELD]);
IF JOBNAME=0 THEN BEGIN JOBNAME:=CURNAME;OPENLOGFILE;END;
IF TERMOFFSET+(STRSTART[CURINPUT.NAMEFIELD+1]-STRSTART[CURINPUT.
NAMEFIELD])>MAXPRINTLINE-2 THEN PRINTLN ELSE IF(TERMOFFSET>0)OR(
FILEOFFSET>0)THEN PRINTCHAR(32);PRINTCHAR(40);PRINT(CURINPUT.NAMEFIELD);
BREAK(TERMOUT);STATE:=NEWLINE;{628:}
BEGIN IF NOT INPUTLN(INPUTFILE[CURINPUT.INDEXFIELD],FALSE)THEN;
FIRMUPTHELIN;BUFFER[CURINPUT.LIMITFIELD]:=37;
FIRST:=CURINPUT.LIMITFIELD+1;CURINPUT.LOCFIELD:=CURINPUT.STARTFIELD;
LINE:=1;END{:628};END;{:627}{650:}PROCEDURE WRITEGF(A,B:GFINDEX);
VAR K:GFINDEX;BEGIN FOR K:=A TO B DO WRITE(GFFILE,GFBUF[K]);END;{:650}
{651:}PROCEDURE GFSWAP;
BEGIN IF GFLIMIT=GFBUFSIZE THEN BEGIN WRITEGF(0,HALFBUF-1);
GFLIMIT:=HALFBUF;GFOFFSET:=GFOFFSET+GFBUFSIZE;GFPTR:=0;
END ELSE BEGIN WRITEGF(HALFBUF,GFBUFSIZE-1);GFLIMIT:=GFBUFSIZE;END;END;
{:651}{653:}PROCEDURE GFFOUR(X:INTEGER);
BEGIN IF X>=0 THEN BEGIN GFBUF[GFPTR]:=X DIV 16777216;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END ELSE BEGIN X:=X+1073741824;
X:=X+1073741824;BEGIN GFBUF[GFPTR]:=(X DIV 16777216)+128;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;END;X:=X MOD 16777216;
BEGIN GFBUF[GFPTR]:=X DIV 65536;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;X:=X MOD 65536;
BEGIN GFBUF[GFPTR]:=X DIV 256;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=X MOD 256;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;END;{:653}{654:}
PROCEDURE GFTWO(X:INTEGER);BEGIN BEGIN GFBUF[GFPTR]:=X DIV 256;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;
BEGIN GFBUF[GFPTR]:=X MOD 256;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;END;PROCEDURE GFTHREE(X:INTEGER);
BEGIN BEGIN GFBUF[GFPTR]:=X DIV 65536;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;
BEGIN GFBUF[GFPTR]:=(X MOD 65536)DIV 256;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=X MOD 256;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;END;{:654}{655:}
PROCEDURE GFPAINT(D:INTEGER);BEGIN IF D<64 THEN BEGIN GFBUF[GFPTR]:=0+D;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;
END ELSE IF D<256 THEN BEGIN BEGIN GFBUF[GFPTR]:=64;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=D;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;END ELSE BEGIN BEGIN GFBUF[GFPTR]:=65;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;GFTWO(D);END;END;
PROCEDURE GFNEWROW(D:INTEGER);
BEGIN IF ABS(D)<=82 THEN BEGIN GFBUF[GFPTR]:=155+D;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END ELSE BEGIN BEGIN GFBUF[GFPTR]:=72;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;GFFOUR(D);END;END;{:655}
{656:}PROCEDURE GFSTRING(S:STRNUMBER);VAR K:POOLPOINTER;
BEGIN FOR K:=STRSTART[S]TO STRSTART[S+1]-1 DO BEGIN GFBUF[GFPTR]:=
STRPOOL[K];GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;END;{:656}
{657:}PROCEDURE INITGF;VAR K:EIGHTBITS;T:INTEGER;BEGIN GFMINX:=4096;
GFMAXX:=-4095;GFMINY:=4096;GFMAXY:=-4096;
FOR K:=0 TO 255 DO CHARPTR[K]:=-1;
IF OUTPUTFILENA=0 THEN BEGIN IF JOBNAME=0 THEN OPENLOGFILE;
PACKJOBNAME(514);WHILE NOT BOPENOUT(GFFILE)DO PROMPTFILENA(515,514);
OUTPUTFILENA:=BMAKENAMESTR(GFFILE);END;BEGIN GFBUF[GFPTR]:=247;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=129;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;OLDSETTING:=SELECTOR;
SELECTOR:=5;PRINT(521);PRINTINT(ROUNDUNSCALE(INTERNAL[11]));
PRINTCHAR(46);PRINTDD(ROUNDUNSCALE(INTERNAL[12]));PRINTCHAR(46);
PRINTDD(ROUNDUNSCALE(INTERNAL[13]));PRINTCHAR(58);
T:=ROUNDUNSCALE(INTERNAL[14]);PRINTDD(T DIV 60);PRINTDD(T MOD 60);
SELECTOR:=OLDSETTING;BEGIN GFBUF[GFPTR]:=(POOLPTR-STRSTART[STRPTR]);
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;
STRSTART[STRPTR+1]:=POOLPTR;GFSTRING(STRPTR);POOLPTR:=STRSTART[STRPTR];
GFPREVPTR:=GFPTR;END;{:657}{658:}PROCEDURE SHIPOUT(H:HALFWORD);
VAR C:INTEGER;PREVM,M:INTEGER;PREVN,N:INTEGER;P,Q:HALFWORD;W,WW:INTEGER;
D:INTEGER;DELTA:INTEGER;Z:INTEGER;BEGIN C:=ROUNDUNSCALE(INTERNAL[15]);
IF(C<0)OR(C>255)THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(522);END;PRINTINT(C);PRINTCHAR(41);BEGIN HELPPTR:=2;
HELPLINE[1]:=523;HELPLINE[0]:=524;END;C:=0;MEM[16].INT:=0;ERROR;END;
CHARPTR[C]:=GFPREVPTR;BEGIN GFBUF[GFPTR]:=67;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;GFFOUR(C);
GFFOUR(ROUNDUNSCALE(INTERNAL[20]));{659:}PREVN:=4096;P:=MEM[H].HH.LH;
N:=MEM[H+1].HH.RH-4096;WHILE P<>H DO BEGIN{660:}
IF MEM[P+1].HH.LH>1 THEN SORTEDGES(P);Q:=MEM[P+1].HH.RH;W:=0;
PREVM:=-268435456;WHILE Q>13000 DO BEGIN D:=MEM[Q].HH.LH-0;M:=D DIV 8;
WW:=W+(D MOD 8)-4;IF W<=0 THEN BEGIN IF WW>0 THEN IF M>PREVM THEN{661:}
BEGIN IF PREVM=-268435456 THEN{663:}BEGIN MM:=M-MEM[H+3].HH.LH;
IF MM<GFXMIN THEN GFXMIN:=MM;
IF PREVN=4096 THEN BEGIN IF N>GFYMAX THEN GFYMAX:=N;GFFOUR(N);
GFFOUR(MM);END ELSE IF PREVN>N+1 THEN{664:}BEGIN DELTA:=PREVN-N-1;
IF M<>Z THEN BEGIN GFNEWROW(Z-M);DELTA:=DELTA-1;END;
IF DELTA<256 THEN BEGIN BEGIN GFBUF[GFPTR]:=69;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=DELTA;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;
END ELSE BEGIN BEGIN GFBUF[GFPTR]:=SKIP2;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;GFTWO(DELTA);END;END{:664}
ELSE GFNEWROW(Z-M);Z:=M{:663}ELSE GFPAINT(M-PREVM);PREVM:=M;END{:661};
END ELSE IF WW<=0 THEN IF M>PREVM THEN{662:}BEGIN GFPAINT(M-PREVM);
PREVM:=M;END{:662};W:=WW;Q:=MEM[Q].HH.RH;END;
IF W<>0 THEN CONFUSION(525);
IF PREVM-MEM[H+3].HH.LH>GFXMAX THEN GFXMAX:=PREVM-MEM[H+3].HH.LH{:660};
P:=MEM[P].HH.LH;N:=N-1;END;IF PREVN=4096 THEN BEGIN GFFOUR(0);GFFOUR(0);
END ELSE IF PREVN<GFYMIN THEN GFYMIN:=PREVN{:659};
BEGIN GFBUF[GFPTR]:=68;GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;
GFPREVPTR:=GFOFFSET+GFPTR;TOTALCHARS:=TOTALCHARS+1;END;{:658}{678:}
PROCEDURE DISPERR(P:HALFWORD;S:STRNUMBER);BEGIN IF INTERACTION=3 THEN;
PRINTLN;PRINTEXP(P,TRUE);PRINTNL(133);PRINT(S);END;{:678}{679:}
PROCEDURE FLUSHCUREXP(V:SCALED);
BEGIN CASE CURTYPE OF 3,5,7,10,12,13,14:BEGIN RECYCLEVALUE(CUREXP);
FREENODE(CUREXP,2);END;6:DELETEPENREF(CUREXP);8,11:TOSSKNOTLIST(CUREXP);
9:TOSSEDGES(CUREXP);16,17,20:FLUSHNODELIS(CUREXP);OTHERS:END;
CURTYPE:=15;CUREXP:=V;END;{:679}{683:}{684:}
PROCEDURE BADEXP(S:STRNUMBER);BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(S);END;PRINT(538);PRINTCMDMOD(CURCMD,CURMOD);
PRINTCHAR(39);BEGIN HELPPTR:=4;HELPLINE[3]:=539;HELPLINE[2]:=540;
HELPLINE[1]:=541;HELPLINE[0]:=542;END;BACKINPUT;CURSYM:=0;CURCMD:=11;
CURMOD:=0;INSERROR;GETXNEXT;END;{:684}{690:}PROCEDURE BEGINAGROUP;
BEGIN IF INTERNAL[6]>0 THEN SHOWCMDMOD(CURCMD,CURMOD);
END PROCEDURE ENDAGROUP;BEGIN END{:690}{702:}PROCEDURE BACKEXPR;
BEGIN BEGINTOKENLI(13002,MAXINOPEN+8);PARAMPTR:=PARAMPTR+1;
IF PARAMPTR>MAXPARAMSTAC THEN BEGIN MAXPARAMSTAC:=PARAMPTR;
IF MAXPARAMSTAC>PARAMSIZE THEN OVERFLOW(478,PARAMSIZE);END;
PARAMSTACK[PARAMPTR-1]:=STASHCUREXP;END;{:702}{704:}
PROCEDURE BADSUBSCRIPT;BEGIN DISPERR(0,552);BEGIN HELPPTR:=3;
HELPLINE[2]:=553;HELPLINE[1]:=554;HELPLINE[0]:=555;END;ERROR;
FLUSHCUREXP(0);END;{:704}{711:}{712:}
FUNCTION SINGLEDEPEND(P:HALFWORD):HALFWORD;VAR Q:HALFWORD;
BEGIN Q:=GETNODE(2);MEM[Q+1].INT:=268435456;MEM[Q].HH.LH:=P;
DEPTAIL:=GETNODE(2);MEM[DEPTAIL+1].INT:=0;MEM[DEPTAIL].HH.LH:=0;
MEM[Q].HH.RH:=DEPTAIL;SINGLEDEPEND:=Q;END;{:712}{713:}
FUNCTION COPYDEPLIST(P:HALFWORD):HALFWORD;VAR Q:HALFWORD;
BEGIN Q:=GETNODE(2);DEPTAIL:=Q;
WHILE TRUE DO BEGIN MEM[DEPTAIL].HH.LH:=MEM[P].HH.LH;
MEM[DEPTAIL+1].INT:=MEM[P+1].INT;IF MEM[DEPTAIL].HH.LH=0 THEN GOTO 30;
MEM[DEPTAIL].HH.RH:=GETNODE(2);DEPTAIL:=MEM[DEPTAIL].HH.RH;
P:=MEM[P].HH.RH;END;30:COPYDEPLIST:=Q;END;{:713}{715:}
PROCEDURE COPYBIGNODE(P:HALFWORD;S:SMALLNUMBER);VAR Q,R,T:HALFWORD;
BEGIN IF MEM[P+1].INT=0 THEN INITBIGNODE(P,S);T:=GETNODE(2);
MEM[T].HH.B1:=11;MEM[T].HH.B0:=CURTYPE;INITBIGNODE(T,S);
Q:=MEM[P+1].INT+S;R:=MEM[T+1].INT+S;REPEAT Q:=Q-2;R:=R-2;
IF MEM[Q].HH.B0=15 THEN BEGIN MEM[R+1].INT:=MEM[Q+1].INT;
MEM[R].HH.B0:=15;
END ELSE BEGIN IF MEM[Q].HH.B0=19 THEN BEGIN MEM[R].HH.B0:=16;
MEM[R+1].HH.LH:=SINGLEDEPEND(Q);
END ELSE BEGIN MEM[R].HH.B0:=MEM[Q].HH.B0;
MEM[R+1].HH.LH:=COPYDEPLIST(Q);END;MEM[DEPTAIL].HH.RH:=MEM[13].HH.RH;
MEM[#+1].HH.RH(MEM[13].HH.RH):=R;MEM[13].HH.RH:=R;MEM[#+1].HH.RH(R):=13;
END;UNTIL Q=P;COPYBIGNODE:=R;END;{:715}
PROCEDURE MAKEEXPCOPY(P:HALFWORD);BEGIN CURTYPE:=MEM[P].HH.B0;
CASE CURTYPE OF 2,15:CUREXP:=MEM[P+1].INT;
3,5,7,10,12:CUREXP:=NEWRINGENTRY(P);4:CUREXP:=MEM[P+1].INT;
6:BEGIN CUREXP:=MEM[P+1].INT;MEM[CUREXP].HH.LH:=MEM[CUREXP].HH.LH+1;END;
9:CUREXP:=COPYEDGES(MEM[P+1].INT);11,8:CUREXP:=COPYPATH(MEM[P+1].INT);
13:COPYBIGNODE(P,12);14:COPYBIGNODE(P,4);
16,17:COPYDEPLIST(MEM[P+1].HH.LH,CURTYPE);18:BEGIN MEM[P].HH.B0:=19;
MEM[P+1].INT:=0;CURTYPE:=16;CUREXP:=SINGLEDEPEND(P);END;
19:BEGIN CURTYPE:=16;CUREXP:=SINGLEDEPEND(P);END;END;END;{:711}{720:}
PROCEDURE BINARYMAC(P,C,N:HALFWORD);VAR Q,R:HALFWORD;BEGIN Q:=GETAVAIL;
R:=GETAVAIL;MEM[Q].HH.RH:=R;MEM[Q].HH.LH:=P;MEM[R].HH.LH:=STASHCUREXP;
MACROCALL(C,Q,N);END;{:720}{723:}PROCEDURE MATERIALIZEP;BEGIN;END;{:723}
{726:}{728:}FUNCTION KNOWNPAIR:HALFWORD;VAR P:HALFWORD;
BEGIN IF CURTYPE<>PAIR THEN BEGIN DISPERR(0,573);BEGIN HELPPTR:=3;
HELPLINE[2]:=574;HELPLINE[1]:=575;HELPLINE[0]:=576;END;ERROR;
FLUSHCUREXP(0);KNOWNPAIR:=0;END ELSE BEGIN P:=MEM[CUREXP+1].INT;
FREENODE(CUREXP,2);{729:}IF MEM[P].HH.B0<>15 THEN BEGIN DISPERR(P,577);
BEGIN HELPPTR:=3;HELPLINE[2]:=578;HELPLINE[1]:=575;HELPLINE[0]:=576;END;
ERROR;RECYCLEVALUE(P);MEM[P].HH.B0:=15;MEM[P+1].INT:=0;END;
IF MEM[P+2].HH.B0<>15 THEN BEGIN DISPERR(P+2,579);BEGIN HELPPTR:=3;
HELPLINE[2]:=580;HELPLINE[1]:=575;HELPLINE[0]:=576;END;ERROR;
RECYCLEVALUE(P+2);MEM[P+2].HH.B0:=15;MEM[P+3].INT:=0;END{:729};
CURTYPE:=1;KNOWNPAIR:=P;END;END;{:728}FUNCTION NEWFRAGMENT;
VAR Q:HALFWORD;BEGIN Q:=GETNODE(KNOTNODESIZE);MEM[Q].HH.B0:=5;
MEM[Q].HH.B1:=4;MEM[Q+5].INT:=65536;P:=KNOWNPAIR;
IF P=0 THEN BEGIN MEM[Q+1].INT:=0;MEM[Q+2].INT:=0;
END ELSE BEGIN MEM[Q+1].INT:=MEM[P+1].INT;MEM[Q+2].INT:=MEM[P+3].INT;
FREENODE(P,4);END;NEWFRAGMENT:=Q;END;{:726}{737:}
PROCEDURE FIXFRAGMENT(P:HALFWORD);
BEGIN IF MEM[P].HH.B1=2 THEN IF(MEM[P+5].INT=0)AND(MEM[P+6].INT=0)THEN
BEGIN MEM[P].HH.B1:=4;MEM[P+5].INT:=65536;END ELSE BEGIN R:=GETNODE(3);
MEM[R+1].INT:=MEM[P+5].INT;MEM[R+2].INT:=MEM[P+6].INT;
MEM[R].HH.RH:=GIVENLIST;GIVENLIST:=R;MEM[P+5].INT:=R;END;
MEM[P].HH.B0:=MEM[P].HH.B1;MEM[P+3].INT:=MEM[P+5].INT;END;{:737}{749:}
{:749}{774:}PROCEDURE FRACMULT(V:FRACTION);VAR P:HALFWORD;
BEGIN IF CURTYPE=15 THEN TAKEFRACTION(CUREXP,V)ELSE IF CURTYPE=14 THEN
BEGIN P:=MEM[CUREXP+1].INT;DEPMULT(P,V,FALSE);DEPMULT(P+2,V,FALSE);
END ELSE DEPMULT(0,V,FALSE);END;{:774}PROCEDURE SCANPRIMARY;
LABEL 20,50,30,31,40,10;VAR P,Q:HALFWORD;C:QUARTERWORD;
STARTOFSTMT:BOOLEAN;LDELIM,RDELIM:HALFWORD;{688:}GROUPLINE:INTEGER;
{:688}{698:}PREHEAD,POSTHEAD,TAIL:HALFWORD;TT:SMALLNUMBER;T:HALFWORD;
MACROREF:HALFWORD;{:698}BEGIN STARTOFSTMT:=BEGINNING;BEGINNING:=FALSE;
20:IF ARITHERROR THEN CLEARARITH;{685:}
{IF PANICKING THEN CHECKMEM(FALSE);}
IF INTERRUPT<>0 THEN IF OKTOINTERRUP THEN BEGIN BACKINPUT;
BEGIN IF INTERRUPT<>0 THEN PAUSEFORINST;END;GETXNEXT;END{:685};
CASE CURCMD OF 8:{686:}BEGIN LDELIM:=CURSYM;RDELIM:=CURMOD;GETXNEXT;
SCANEXPRESSI;IF(CURCMD=66)AND(CURTYPE>=16)THEN{687:}BEGIN P:=GETNODE(2);
MEM[P].HH.B0:=14;MEM[P].HH.B1:=11;INITBIGNODE(4);STASHIN(P);GETXNEXT;
SCANEXPRESSI;IF CURTYPE<16 THEN BEGIN DISPERR(0,543);BEGIN HELPPTR:=4;
HELPLINE[3]:=544;HELPLINE[2]:=545;HELPLINE[1]:=546;HELPLINE[0]:=547;END;
ERROR;FLUSHCUREXP(0);END;STASHIN(P+2);CHECKDELIMIT(LDELIM,RDELIM);
CURTYPE:=14;CUREXP:=P;END{:687}ELSE CHECKDELIMIT(LDELIM,RDELIM);
END{:686};9:{689:}BEGIN GROUPLINE:=LINE;BEGINAGROUP;REPEAT DOSTATEMENT;
UNTIL CURCMD<>67;IF CURCMD<>68 THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(548);END;PRINTINT(LINE);PRINT(549);BEGIN HELPPTR:=2;
HELPLINE[1]:=550;HELPLINE[0]:=551;END;BACKERROR;CURCMD:=68;CURSYM:=2095;
END;ENDAGROUP;END{:689};10:{691:}BEGIN CURTYPE:=2;CUREXP:=CURMOD;
END{:691};12:{692:}BEGIN CURTYPE:=4;CUREXP:=CURMOD;END{:692};11:{695:}
BEGIN CUREXP:=CURMOD;CURTYPE:=15;GETXNEXT;
IF CURCMD<>29 THEN DENOM:=0 ELSE BEGIN GETXNEXT;
IF CURCMD<>11 THEN BEGIN BACKINPUT;CURCMD:=29;CURMOD:=62;CURSYM:=2093;
GOTO 10;END;NUM:=CUREXP;DENOM:=CURMOD;CUREXP:=MAKESCALED(NUM,DENOM);END;
IF CURCMD>=7 THEN IF CURCMD<19 THEN BEGIN P:=STASHCUREXP;SCANPRIMARY;
IF(ABS(NUM)>=ABS(DENOM))OR(CURTYPE<14)THEN DOBINARY(P,61)ELSE BEGIN
FRACMULT(TAKEFRACTION(NUM,DENOM));FREENODE(P,2);END;END;GOTO 10;
END{:695};13:{693:}DONULLARY(CURMOD){:693};14,7,19:{694:}
BEGIN C:=CURMOD;GETXNEXT;SCANPRIMARY;DOUNARY(C);GOTO 10;END{:694};
15:{696:}BEGIN C:=CURMOD;GETXNEXT;SCANEXPRESSI;
IF CURCMD<>OF THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(495);END;PRINTCMDMOD(15,C);BEGIN HELPPTR:=1;HELPLINE[0]:=496;END;
BACKERROR;END;P:=STASHCUREXP;GETXNEXT;SCANPRIMARY;DOBINARY(P,C);GOTO 10;
END{:696};INTERNAL,17,18:{699:}BEGIN IF CURCMD<>18 THEN{709:}
BEGIN C:=CURCMD;P:=CURMOD;Q:=CURSYM;GETXNEXT;
IF CURCMD=65 THEN IF STARTOFSTMT THEN IF C=INTERNAL THEN BEGIN CURTYPE:=
20;CUREXP:=GETAVAIL;MEM[CUREXP].HH.LH:=Q;GOTO 10;END;GOTO 40;END{:709};
IF CURMOD=0 THEN TT:=0 ELSE BEGIN Q:=CURMOD;TT:=MEM[Q].HH.B0;END;
PREHEAD:=GETAVAIL;TAIL:=PREHEAD;POSTHEAD:=0;
WHILE TRUE DO BEGIN T:=CURTOK;
IF TT>=22 THEN IF TT>UNSUFFIXED THEN BEGIN POSTHEAD:=GETAVAIL;
TAIL:=POSTHEAD;TT:=0;MACROREF:=MEM[Q+1].INT;
MEM[MACROREF].HH.LH:=MEM[MACROREF].HH.LH+1;END ELSE{707:}
BEGIN P:=GETAVAIL;MEM[PREHEAD].HH.LH:=MEM[PREHEAD].HH.RH;
MEM[PREHEAD].HH.RH:=P;MEM[P].HH.LH:=T;MACROCALL(MEM[Q+1].INT,PREHEAD,0);
GOTO 20;END{:707};MEM[TAIL].HH.RH:=T;GETXNEXT;IF CURCMD=27 THEN{700:}
BEGIN GETXNEXT;GETEXPRESSIO;IF CURCMD<>55 THEN{701:}BEGIN BACKINPUT;
BACKEXPR;CURCMD:=27;CURSYM:=2092;END{:701}
ELSE BEGIN IF CURTYPE<>15 THEN BADSUBSCRIPT;CURCMD:=11;CURMOD:=CUREXP;
CURSYM:=0;END;END{:700};IF CURCMD<>11 THEN IF CURCMD<>18 THEN GOTO 30;
TAIL:=T;IF TT<>0 THEN{705:}BEGIN P:=MEM[PREHEAD].HH.RH;Q:=MEM[P].HH.LH;
TT:=0;IF EQTB[Q].LH=18 THEN BEGIN Q:=EQTB[Q].RH;
WHILE TRUE DO BEGIN P:=MEM[P].HH.RH;IF P=0 THEN BEGIN TT:=MEM[Q].HH.B0;
GOTO 31;END;IF MEM[Q].HH.B0<>21 THEN GOTO 31;
Q:=MEM[MEM[Q+1].HH.LH].HH.RH;
IF P>13000 THEN BEGIN REPEAT Q:=MEM[Q].HH.RH;
UNTIL MEM[Q+2].HH.LH>=MEM[P].HH.LH;
IF MEM[Q+2].HH.LH>MEM[P].HH.LH THEN GOTO 31;END;END;END;31:END{:705};
END;30:{706:}IF POSTHEAD<>0 THEN{708:}BEGIN BACKINPUT;P:=GETAVAIL;
Q:=MEM[POSTHEAD].HH.RH;MEM[PREHEAD].HH.LH:=MEM[PREHEAD].HH.RH;
MEM[PREHEAD].HH.RH:=POSTHEAD;MEM[POSTHEAD].HH.LH:=Q;
MEM[POSTHEAD].HH.RH:=P;MEM[P].HH.LH:=MEM[Q].HH.RH;MEM[Q].HH.RH:=0;
MACROCALL(MACROREF,PREHEAD,0);
MEM[MACROREF].HH.LH:=MEM[MACROREF].HH.LH-1;GOTO 20;END{:708};
Q:=MEM[PREHEAD].HH.RH;BEGIN MEM[PREHEAD].HH.RH:=AVAIL;AVAIL:=PREHEAD;
{DYNUSED:=DYNUSED-1;}END;
IF CURCMD=65 THEN IF STARTOFSTMT THEN BEGIN CURTYPE:=20;CUREXP:=Q;END;
P:=FINDVARIABLE(Q);IF P=0 THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(556);END;SHOWTOKENLIS(Q,0,1000);PRINT(557);
BEGIN HELPPTR:=5;HELPLINE[4]:=558;HELPLINE[3]:=559;HELPLINE[2]:=560;
HELPLINE[1]:=561;HELPLINE[0]:=562;END;FLUSHNODELIS(Q);BACKINPUT;
CURCMD:=11;CURMOD:=0;CURSYM:=0;INSERR;GOTO 20;END{:706};40:{710:}
MAKEEXPCOPY(P);GOTO 10{:710};END{:699};OTHERS:BEGIN BADEXP(537);GOTO 20;
END END;50:GETXNEXT;10:END;{:683}{716:}PROCEDURE SCANSUFFIX;
VAR H,T:HALFWORD;BEGIN H:=GETAVAIL;T:=H;
WHILE TRUE DO BEGIN IF CURCMD=27 THEN{717:}BEGIN GETXNEXT;SCANEXPRESSI;
IF CURTYPE<>15 THEN BADSUBSCRIPT;
IF CURCMD=RIGHTBRACKT THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(563);END;BEGIN HELPPTR:=3;HELPLINE[2]:=564;
HELPLINE[1]:=565;HELPLINE[0]:=566;END BACKERROR;END;CURCMD:=11;
CURMOD:=CUREXP;END{:717};
IF CURCMD=11 THEN P:=NEWNUMTOK(CURMOD)ELSE IF CURCMD=18 THEN BEGIN P:=
GETAVAIL;MEM[P].HH.LH:=CURSYM;END ELSE GOTO 30;MEM[T].HH.RH:=P;T:=P;
GETXNEXT;END;30:CUREXP:=MEM[H].HH.RH;BEGIN MEM[H].HH.RH:=AVAIL;AVAIL:=H;
{DYNUSED:=DYNUSED-1;}END;CURTYPE:=20;END;{:716}{718:}
PROCEDURE SCANSECONDAR;LABEL 20,22,10;VAR P,Q,R:HALFWORD;C,D:HALFWORD;
MACNAME:HALFWORD;BEGIN 20:IF(CURCMD<7)OR(CURCMD>19)THEN BADEXP(567);
SCANPRIMARY;22:IF CURCMD>=26 THEN IF CURCMD<=30 THEN BEGIN P:=STASHTEMP;
C:=CURMOD;D:=CURCMD;IF D=28 THEN BEGIN MACNAME:=CURSYM;
MEM[C].HH.LH:=MEM[C].HH.LH+1;END;GETXNEXT;IF D=27 THEN{721:}
BEGIN SCANEXPRESSI;IF CURCMD<>66 THEN BEGIN{701:}BEGIN BACKINPUT;
BACKEXPR;CURCMD:=27;CURSYM:=2092;END{:701};GOTO 10;END;Q:=STASHCUREXP;
GETXNEXT;GETEXPRESSIO;
IF CURCMD<>55 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(563);END;BEGIN HELPPTR:=3;HELPLINE[2]:=568;HELPLINE[1]:=565;
HELPLINE[0]:=566;END BACKERROR;END;R:=STASHCUREXP;MAKEEXPCOPY(Q);
DOBINARY(R,60);DOBINARY(P,61);DOBINARY(Q,59);GETXNEXT;END{:721}
ELSE BEGIN SCANPRIMARY;IF D<>28 THEN DOBINARY(P,C)ELSE BEGIN BACKINPUT;
BINARYMAC(P,C,MACNAME);MEM[C].HH.LH:=MEM[C].HH.LH-1;GETXNEXT;GOTO 20;
END;END;GOTO 22;END;10:END;{:718}{722:}PROCEDURE SCANTERTIARY;
LABEL 20,22;VAR P,Q,R:HALFWORD;C,D:HALFWORD;MACNAME:HALFWORD;
BEGIN 20:IF(CURCMD<7)OR(CURCMD>19)THEN BADEXP(569);SCANSECONDAR;
IF CURTYPE=8 THEN MATERIALIZEP;
22:IF CURCMD>=19 THEN IF CURCMD<=22 THEN IF(CURCMD<>22)OR(CURTYPE<11)
THEN BEGIN P:=STASHTEMP;C:=CURMOD;D:=CURCMD;
IF D=20 THEN BEGIN MACNAME:=CURSYM;MEM[C].HH.LH:=MEM[C].HH.LH+1;END;
GETXNEXT;IF D=57 THEN{724:}BEGIN{725:}BEGIN UNSTASHCUREX(P);
Q:=NEWFRAGMENT;END{:725};GETXNEXT;IF CURCMD=53 THEN{730:}BEGIN GETXNEXT;
SCANEXPRESSI;IF(CURTYPE<>15)OR(CUREXP<0)THEN BEGIN DISPERR(0,581);
BEGIN HELPPTR:=1;HELPLINE[0]:=582;END;ERROR;FLUSHCUREXP(65536);END;
MEM[Q].HH.B1:=3;MEM[Q+5].INT:=CUREXP;END{:730}ELSE{731:}
BEGIN MEM[Q].HH.B1:=2;SCANEXPRESSI;IF CURTYPE>14 THEN{732:}
BEGIN IF CURTYPE<>15 THEN BEGIN DISPERR(0,577);BEGIN HELPPTR:=3;
HELPLINE[2]:=578;HELPLINE[1]:=575;HELPLINE[0]:=576;END;ERROR;
FLUSHCUREXP(0);END;MEM[Q+5].INT:=CUREXP;
IF CURCMD<>66 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(583);END;BEGIN HELPPTR:=2;HELPLINE[1]:=584;HELPLINE[0]:=585;END;
BACKERROR;END;GETXNEXT;SCANEXPRESSI;
IF CURTYPE<>15 THEN BEGIN DISPERR(0,579);BEGIN HELPPTR:=3;
HELPLINE[2]:=580;HELPLINE[1]:=575;HELPLINE[0]:=576;END;ERROR;
FLUSHCUREXP(0);END;MEM[Q+6].INT:=CUREXP;END{:732}
ELSE BEGIN P:=KNOWNPAIR;IF P=0 THEN BEGIN MEM[Q+5].INT:=0;
MEM[Q+6].INT:=0;END ELSE BEGIN MEM[Q+5].INT:=MEM[P+1].INT;
MEM[Q+6].INT:=MEM[P+3].INT;FREENODE(P,4);END;END;END{:731};
IF CURCMD<>56 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(570);END;BEGIN HELPPTR:=3;HELPLINE[2]:=571;HELPLINE[1]:=572;
HELPLINE[0]:=566;END BACKERROR;END;CURTYPE:=11;CUREXP:=Q;GETXNEXT;{733:}
IF MEM[Q].HH.B1=2 THEN IF MEM[Q+5].INT=0 THEN IF MEM[Q+6].INT=0 THEN
BEGIN P:=GETNODE(2);MEM[P].HH.B0:=14;MEM[P].HH.B1:=11;INITBIGNODE(P,4);
CUREXP:=P;CURTYPE:=14;P:=MEM[P+1].INT;MEM[P].HH.B0:=15;
MEM[P+1].INT:=MEM[Q+1].INT;MEM[P+2].HH.B0:=15;
MEM[P+3].INT:=MEM[Q+2].INT;FREENODE(Q,KNOTNODESIZE);END{:733};END{:724}
ELSE BEGIN SCANSECONDAR;IF D<>20 THEN DOBINARY(P,C)ELSE BEGIN BACKINPUT;
BINARYMAC(P,C,MACNAME);MEM[C].HH.LH:=MEM[C].HH.LH-1;GETXNEXT;GOTO 20;
END;END;GOTO 22;END;END;{:722}{734:}PROCEDURE SCANEXPRESSI;
LABEL 20,22,10;VAR P,Q,R:HALFWORD;C,D:HALFWORD;STARTOFSTMT:BOOLEAN;
MACNAME:HALFWORD;BEGIN STARTOFSTMT:=BEGINNING;
20:IF(CURCMD<7)OR(CURCMD>19)THEN BADEXP(586);SCANTERTIARY;
22:IF CURCMD>=22 THEN IF CURCMD<=25 THEN IF(CURCMD<>25)OR NOT
STARTOFSTMT THEN BEGIN P:=STASHTEMP;C:=CURMOD;D:=CURCMD;
IF D=24 THEN BEGIN MACNAME:=CUR:=SYM;MEM[C].HH.LH:=MEM[C].HH.LH+1;END;
IF D<=23 THEN{735:}BEGIN{736:}BEGIN ABORTPATH:=FALSE;GIVENLIST:=0;
IF MEM[P].HH.B0=14 THEN BEGIN UNSTASHCUREX(P);P:=NEWFRAGMENT;
END ELSE IF MEM[P].HH.B0=11 THEN P:=MEM[P+1].INT ELSE BEGIN ABORTPATH:=
TRUE;GOTO 30;END;Q:=P;
IF MEM[P].HH.B0=5 THEN FIXFRAGMENT(P)ELSE BEGIN MEM[P].HH.B0:=ENDPOINT;
WHILE MEM[MEM[Q].HH.RH].HH.B0<>ENDPOINT DO Q:=MEM[Q].HH.RH;
MEM[Q].HH.B1:=0;END;30:END{:736};CONTINUEPATH:D:=CURCMD;
IF D=23 THEN{738:}BEGIN GETXNEXT;IF CURCMD=51 THEN{741:}
IF CURMOD=0 THEN BEGIN MEM[Q+6].INT:=0;T:=0;GETXNEXT;
END ELSE BEGIN GETXNEXT;SCANEXPRESSI;{742:}
IF(CURTYPE<>15)OR(CUREXP<MINTENSION)THEN BEGIN DISPERR(0,590);
BEGIN HELPPTR:=1;HELPLINE[0]:=591;END;ERROR;FLUSHCUREXP(65536);END{:742}
;MEM[Q+6].INT:=CUREXP;IF CURCMD<>26 THEN T:=CUREXP ELSE BEGIN GETXNEXT;
SCANEXPRESSI;{742:}
IF(CURTYPE<>15)OR(CUREXP<MINTENSION)THEN BEGIN DISPERR(0,590);
BEGIN HELPPTR:=1;HELPLINE[0]:=591;END;ERROR;FLUSHCUREXP(65536);END{:742}
;T:=CUREXP;END;END{:741}ELSE IF CURCMD=50 THEN{743:}
BEGIN MEM[Q].HH.B1:=1;GETXNEXT;SCANEXPRESSI;PP:=KNOWNPAIR;
IF PP=0 THEN BEGIN MEM[Q+5].INT:=0;MEM[Q+6].INT:=0;
END ELSE BEGIN MEM[Q+5].INT:=MEM[PP+1].INT;MEM[Q+6].INT:=MEM[PP+3].INT;
FREENODE(PP,4);END;IF CURCMD<>26 THEN BEGIN X:=MEM[Q+5].INT;
Y:=MEM[Q+6].INT;END ELSE BEGIN GETXNEXT;SCANEXPRESSI;PP:=KNOWNPAIR;
IF PP=0 THEN BEGIN X:=0;Y:=0;END ELSE BEGIN X:=MEM[PP+1].INT;
Y:=MEM[PP+3].INT;FREENODE(PP,4);END;END;END{:743}
ELSE BEGIN MEM[Q+6].INT:=65536;T:=65536;BACKINPUT;GOTO 31;END;
50:IF CURCMD<>23 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(587);END;BEGIN HELPPTR:=1;HELPLINE[0]:=588;END;BACKERROR;END;
31:END{:738};GETXNEXT;IF(CURCMD=52)AND NOT ABORTPATH THEN{745:}
BEGIN CYCLEHIT:=TRUE;PP:=P;QQ:=P;IF D=22 THEN IF P=Q THEN BEGIN D:=23;
MEM[Q+6].INT:=65536;T:=65536;END;END{:745}ELSE BEGIN CYCLEHIT:=FALSE;
SCANTERTIARY;IF ABORTPATH THEN BEGIN DOBINARY(P,C);GOTO 22;END;{744:}
BEGIN IF CURTYPE<>11 THEN PP:=NEWFRAGMENT ELSE PP:=CUREXP;QQ:=PP;
IF MEM[PP].HH.B0<>5 THEN FIXFRAGMENT(PP)ELSE BEGIN MEM[PP].HH.B0:=
ENDPOINT;WHILE MEM[MEM[QQ].HH.RH].HH.B0<>ENDPOINT DO QQ:=MEM[QQ].HH.RH;
MEM[QQ].HH.B1:=0;END;END{:744};END;{746:}
BEGIN IF D=22 THEN IF(MEM[Q+1].INT<>MEM[PP+1].INT)OR(MEM[Q+2].INT<>MEM[
PP+2].INT)THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(592);END;BEGIN HELPPTR:=3;HELPLINE[2]:=593;HELPLINE[1]:=594;
HELPLINE[0]:=595;END;ERROR;D:=23;MEM[Q+6].INT:=65536;T:=65536;END;
IF D=22 THEN{747:}BEGIN IF MEM[Q].HH.B0=4 THEN MEM[Q].HH.B0:=3;
IF MEM[PP].HH.B1=4 THEN MEM[PP].HH.B1:=3;MEM[Q].HH.B1:=MEM[PP].HH.B1;
MEM[Q+5].INT:=MEM[PP+5].INT;MEM[Q+6].INT:=MEM[PP+6].INT;
MEM[Q].HH.RH:=MEM[PP].HH.RH;FREENODE(PP,KNOTNODESIZE);
IF QQ=PP THEN QQ:=Q;END{:747}ELSE BEGIN MEM[Q].HH.RH:=PP;
IF MEM[Q].HH.B1<>1 THEN MEM[PP+4].INT:=T ELSE BEGIN MEM[PP+3].INT:=X;
MEM[PP+4].INT:=Y;MEM[PP].HH.B0:=1;END;END;END{:746};
IF CURCMD>=22 THEN IF CURCMD<=23 THEN IF NOT CYCLEHIT THEN GOTO
CONTINUEPATH;{748:}IF CYCLEHIT THEN BEGIN IF D=22 THEN P:=Q;
END ELSE BEGIN MEM[P].HH.B0:=0;IF MEM[P].HH.B1=4 THEN MEM[P].HH.B1:=3;
MEM[Q].HH.B1:=0;IF MEM[Q].HH.B0=4 THEN MEM[Q].HH.B0:=3;MEM[Q].HH.RH:=P;
END;MAKECHOICES(P,GIVENLIST);CURTYPE:=11;CUREXP:=P END{:748};END{:735}
ELSE BEGIN GETXNEXT;SCANTERTIARY;
IF D<>24 THEN DOBINARY(P,C)ELSE BEGIN BACKINPUT;BINARYMAC(P,C,MACNAME);
MEM[C].HH.LH:=MEM[C].HH.LH-1;GETXNEXT;GOTO 20;END;END;GOTO 22;END;
10:END;{:734}{753:}PROCEDURE DONULLARY(C:QUARTERWORD);
BEGIN BEGIN IF ARITHERROR THEN CLEARARITH;END;
IF INTERNAL[6]>0 THEN SHOWCMDMOD(13,C);CASE C OF 33:BEGIN CURTYPE:=15;
CUREXP:=NORMRAND;END;OTHERS:BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(596);END;PRINTOP(C);BEGIN HELPPTR:=2;
HELPLINE[1]:=597;HELPLINE[0]:=598;END;CURTYPE:=15;CUREXP:=0;ERROR;
END END;BEGIN IF ARITHERROR THEN CLEARARITH;END;END;{:753}{754:}{755:}
PROCEDURE BADUNARY(C:QUARTERWORD);VAR P:HALFWORD;BEGIN DISPERR(0,600);
PRINTOP(C);PRINTCHAR(40);
IF CURTYPE<16 THEN IF CURTYPE<>14 THEN PRINTTYPE(CURTYPE)ELSE BEGIN P:=
MEM[CUREXP+1].INT;
IF(MEM[P].HH.B0<>15)OR(MEM[P+2].HH.B0<>15)THEN PRINT(601)ELSE PRINT(209)
;END ELSE PRINT(602);PRINTCHAR(41);BEGIN HELPPTR:=3;HELPLINE[2]:=603;
HELPLINE[1]:=604;HELPLINE[0]:=605;END;ERROR;END;{:755}{758:}
PROCEDURE NEGATEDEPLIS(P:HALFWORD);LABEL 10;
BEGIN WHILE TRUE DO BEGIN MEM[P+1].INT:=-MEM[P+1].INT;
IF MEM[P].HH.LH=0 THEN GOTO 10;P:=MEM[P].HH.RH;END;10:END;{:758}
PROCEDURE DOUNARY(C:QUARTERWORD);VAR P:HALFWORD;
BEGIN BEGIN IF ARITHERROR THEN CLEARARITH;END;
IF INTERNAL[6]>0 THEN{756:}BEGIN BEGINDIAGNOS;PRINTNL(123);PRINTOP(C);
PRINTCHAR(40);PRINTEXP(0,FALSE);PRINTCHAR(41);ENDDIAGNOSTI(FALSE);
END{:756};CASE C OF 59:IF CURTYPE<14 THEN BADUNARY(59);60:{757:}
CASE CURTYPE OF 14:BEGIN P:=MEM[CUREXP+1].INT;
IF MEM[P].HH.B0=15 THEN MEM[P+1].INT:=-MEM[P+1].INT ELSE NEGATEDEPLIS(
MEM[P+1].HH.LH);
IF MEM[P+2].HH.B0=15 THEN MEM[P+3].INT:=-MEM[P+3].INT ELSE NEGATEDEPLIS(
MEM[P+3].HH.LH);END;16,17:NEGATEDEPLIS(CUREXP);15:CUREXP:=-CUREXP;
OTHERS:BADUNARY(60)END{:757};{759:}
51,52,53,54,55,56,57:IF CURTYPE<>15 THEN BADUNARY(C)ELSE CASE C OF 51:
CUREXP:=SQUARERT(CUREXP);52:CUREXP:=MEXP(CUREXP);
53:CUREXP:=MLOG(CUREXP);
54,55:BEGIN IF ABS(CUREXP)>=134217728 THEN CUREXP:=CUREXP MOD 23592960;
NSINCOS(CUREXP*16);
IF C=54 THEN CUREXP:=(NSIN+2048)DIV 4096 ELSE CUREXP:=(NCOS+2048)DIV
4096;END;56:CUREXP:=TRUNCSCALED(CUREXP);57:CUREXP:=UNIFRAND(CUREXP);END;
{:759}{760:}
58:IF CURTYPE<>PAIR THEN BADUNARY(58)ELSE BEGIN P:=MEM[CUREXP+1].INT;
IF(MEM[P].HH.B0<>15)OR(MEM[P+2].HH.B0<>15)THEN BADUNARY(58)ELSE
FLUSHCUREXP(NATAN(MEM[P+1].INT,MEM[P+3].INT)DIV 16);END;{:760}
OTHERS:BEGIN DISPERR(0,596);PRINTOP(C);BEGIN HELPPTR:=2;
HELPLINE[1]:=597;HELPLINE[0]:=599;END;ERROR;END END;
BEGIN IF ARITHERROR THEN CLEARARITH;END;END;{:754}{761:}{762:}
PROCEDURE BADBINARY(P:HALFWORD;C:QUARTERWORD);BEGIN DISPERR;
DISPERR(0,607);
IF MEM[P].HH.B0<16 THEN PRINTTYPE(MEM[P].HH.B0)ELSE PRINT(602);
PRINTCHAR(41);PRINTOP(C);PRINTCHAR(40);
IF CURTYPE<16 THEN PRINTTYPE(CURTYPE)ELSE PRINT(602);PRINTCHAR(41);
BEGIN HELPPTR:=3;HELPLINE[2]:=608;HELPLINE[1]:=609;HELPLINE[0]:=610;END;
ERROR;END;{:762}{765:}{771:}PROCEDURE DEPFINISH(V,Q:HALFWORD;
T:SMALLNUMBER);
BEGIN IF MEM[V].HH.LH=0 THEN IF Q=0 THEN BEGIN CUREXP:=MEM[V+1].INT;
CURTYPE:=15;FREENODE(V,2);END ELSE BEGIN V:=MEM[V+1].INT;
RECYCLEVALUE(Q);MEM[Q+1].INT:=V;MEM[Q].HH.B0:=15;
END ELSE IF Q=0 THEN BEGIN CUREXP:=V;CURTYPE:=T;
END ELSE BEGIN MEM[Q+1].HH.LH:=V;MEM[Q].HH.B0:=T;END;END;{:771}
PROCEDURE ADDORSUBTRAC(P,Q:HALFWORD;C:QUARTERWORD);LABEL 10;
VAR T:SMALLNUMBER;V:INTEGER;BEGIN IF Q=0 THEN BEGIN T:=CURTYPE;
V:=CUREXP;END ELSE BEGIN T:=MEM[Q].HH.B0;
IF T<16 THEN V:=MEM[Q+1].INT ELSE V:=MEM[Q+1].HH.LH;END;
IF T=15 THEN BEGIN IF C=60 THEN V:=-V;
IF MEM[P].HH.B0=15 THEN BEGIN V:=MEM[P+1].INT+V;
IF Q=0 THEN CUREXP:=V ELSE MEM[Q+1].INT:=V;GOTO 10;{766:}
R:=MEM[P+1].HH.LH;WHILE MEM[R].HH.LH<>0 DO R:=MEM[R].HH.RH;
MEM[R+1].INT:=MEM[R+1].INT+V;IF Q=0 THEN BEGIN CUREXP:=MEM[P+1].HH.LH;
CURTYPE:=MEM[P].HH.B0;MEM[#+1].HH.RH(MEM[R].HH.RH):=MEM[#+1].HH.RH(P);
MEM[MEM[#+1].HH.RH(P)].HH.RH:=MEM[R].HH.RH;MEM[R].HH.RH:=0;
END ELSE BEGIN MEM[Q+1].HH.LH:=MEM[P+1].HH.LH;
MEM[Q].HH.B0:=MEM[P].HH.B0;MEM[#+1].HH.RH(Q):=MEM[#+1].HH.RH(P);
MEM[MEM[#+1].HH.RH(P)].HH.RH:=Q;END;MEM[P].HH.B0:=15;{:766};
END ELSE BEGIN IF C=60 THEN NEGATEDEPLIS(V);{767:}
IF MEM[P].HH.B0=15 THEN{769:}
BEGIN WHILE MEM[V].HH.LH<>0 DO V:=MEM[V].HH.RH;
MEM[V+1].INT:=MEM[P+1].INT+MEM[V+1].INT;END{:769}
ELSE BEGIN S:=MEM[P].HH.B0;R:=MEM[P+1].HH.LH;
IF T=16 THEN BEGIN IF S=16 THEN IF MAXCOEF(R)+MAXCOEF(V)<COEFBOUND THEN
BEGIN V:=PPLUSFQ(V,268435456,R,16);GOTO 30;END;{768:}T:=17;U:=V;
WHILE MEM[U].HH.LH<>0 DO BEGIN MEM[U+1].INT:=(MEM[U+1].INT+2048)DIV 4096
;U:=MEM[U].HH.RH;END{:768};END;
IF S=17 THEN V:=PPLUSFQ(V,268435456,R,16)ELSE V:=PPLUSFQ(V,65536,R,17);
IF FIXNEEDED THEN FIXDEPENDENC;30:{770:}DEPFINISH(V,Q,T){:770};END{:767}
;END;10:END;{:765}{773:}PROCEDURE DEPMULT(P:HALFWORD;V:INTEGER;
VISSCALED:BOOLEAN);VAR Q:HALFWORD;S,T:SMALLNUMBER;W:FRACTION;
BEGIN IF P=0 THEN BEGIN T:=CURTYPE;Q:=CUREXP;
END ELSE BEGIN T:=MEM[P].HH.B0;Q:=MEM[P+1].HH.LH;END;S:=T;
IF T=16 THEN IF VISSCALED THEN BEGIN W:=MAXCOEF(Q);
IF ABGEQCD(W,ABS(V),626349396,U)THEN T:=17;END;
Q:=PTIMESV(Q,V,S,T,VISSCALED);DEPFINISH(Q,P,T);END;{:773}{776:}
PROCEDURE DEPDIV(P:HALFWORD;V:SCALED);VAR Q:HALFWORD;S,T:SMALLNUMBER;
W:FRACTION;BEGIN IF P=0 THEN BEGIN T:=CURTYPE;Q:=CUREXP;
END ELSE BEGIN T:=MEM[P].HH.B0;Q:=MEM[P+1].HH.LH;END;S:=T;
IF T=16 THEN BEGIN W:=MAXCOEF(Q);
IF ABGEQCD(W,65536,626349396,ABS(V))THEN T:=17;END;Q:=POVERV(Q,V,S,T);
DEPFINISH(Q,P,T);END;{:776}PROCEDURE DOBINARY(P:HALFWORD;C:QUARTERWORD);
VAR Q,R,S:HALFWORD;BEGIN BEGIN IF ARITHERROR THEN CLEARARITH;END;
IF INTERNAL[6]>0 THEN{763:}BEGIN BEGINDIAGNOS;PRINTNL(611);
PRINTEXP(P,FALSE);PRINTCHAR(41);PRINTOP(C);PRINTCHAR(40);
PRINTEXP(0,FALSE);PRINTCHAR(41);ENDDIAGNOSTI(FALSE);END{:763};
CASE C OF 59,60:{764:}
IF(CURTYPE<14)OR(MEM[P].HH.B0<14)THEN BADBINARY(P,C)ELSE IF CURTYPE=14
THEN IF MEM[P].HH.B0<>14 THEN BADBINARY(P,C)ELSE BEGIN Q:=MEM[P+1].INT;
R:=MEM[CUREXP+1].INT;ADDORSUBTRAC(Q,R,C);ADDORSUBTRAC(Q+2,R+2,C);
END ELSE IF MEM[P].HH.B0=14 THEN BADBINARY(P,C)ELSE ADDORSUBTRAC(P,0){:
764};{772:}
61:IF(CURTYPE<14)OR(MEM[P].HH.B0<14)OR((CURTYPE<>15)AND(MEM[P].HH.B0<>15
))THEN BADBINARY(P,61)ELSE BEGIN IF MEM[P].HH.B0=15 THEN BEGIN V:=MEM[P
+1].INT;FREENODE(P,2);END ELSE BEGIN V:=CUREXP;UNSTASHCUREX(P);END;
IF CURTYPE=15 THEN TAKESCALED(CUREXP,V)ELSE IF CURTYPE=14 THEN BEGIN P:=
MEM[CUREXP+1].INT;DEPMULT(P,V,TRUE);DEPMULT(P+2,V,TRUE);
END ELSE DEPMULT(0,V,TRUE);GOTO 10;END;{:772}{775:}
62:IF(CURTYPE<>15)OR(MEM[P].HH.B0<14)THEN BADBINARY(P,62)ELSE BEGIN V:=
CUREXP;UNSTASHCUREX(P);IF V=0 THEN{777:}BEGIN DISPERR(0,612);
BEGIN HELPPTR:=2;HELPLINE[1]:=613;HELPLINE[0]:=614;END;ERROR;END{:777}
ELSE BEGIN IF CURTYPE=15 THEN MAKESCALED(CUREXP,V)ELSE IF CURTYPE=14
THEN BEGIN P:=MEM[CUREXP+1].INT;DEPDIV(P,V);DEPDIV(P+2,V);
END ELSE DEPDIV(0,V);END;GOTO 10;END;{:775}OTHERS:BEGIN DISPERR(P,TRUE);
DISPERR(0,596);PRINTOP(C);BEGIN HELPPTR:=2;HELPLINE[1]:=597;
HELPLINE[0]:=606;END;ERROR;END END;RECYCLEVALUE(P);FREENODE(P,2);
10:BEGIN IF ARITHERROR THEN CLEARARITH;END;END;{:761}{778:}{790:}
PROCEDURE STOREBASEFIL;LABEL 41,42,31,32;VAR J,K,L:INTEGER;P,Q:HALFWORD;
X:INTEGER;W:FOURQUARTERS;BEGIN{792:}
IF SAVEPTR<>0 THEN BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(637);END;BEGIN HELPPTR:=1;HELPLINE[0]:=638;END;
BEGIN IF INTERACTION=3 THEN INTERACTION:=2;ERROR;
{IF INTERACTION>0 THEN DEBUGHELP;}HISTORY:=3;JUMPOUT;END;END{:792};
{807:}SELECTOR:=5;PRINT(642);PRINT(JOBNAME);PRINTCHAR(32);
PRINTINT(11 MOD 100);PRINTCHAR(46);PRINTINT(12);PRINTCHAR(46);
PRINTINT(13);PRINTCHAR(41);
IF INTERACTION=0 THEN SELECTOR:=2 ELSE SELECTOR:=3;
BEGIN IF POOLPTR+1>POOLSIZE THEN OVERFLOW(129,POOLSIZE-INITPOOLPTR);END;
BASEIDENT:=MAKESTRING;PACKJOBNAME(643);
WHILE NOT WOPENOUT(BASEFILE)DO PROMPTFILENA(644,643);PRINTNL(645);
PRINT(WMAKENAMESTR(BASEFILE));BEGIN STRPTR:=STRPTR-1;
POOLPTR:=STRSTART[STRPTR];END;PRINTNL(BASEIDENT){:807};{795:}
BEGIN BASEFILE↑.INT:=207595411;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=13000;PUT(BASEFILE);END;BEGIN BASEFILE↑.INT:=2100;
PUT(BASEFILE);END;BEGIN BASEFILE↑.INT:=1777;PUT(BASEFILE);END{:795};
{797:}BEGIN BASEFILE↑.INT:=POOLPTR;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=STRPTR;PUT(BASEFILE);END;
FOR K:=0 TO STRPTR DO BEGIN BASEFILE↑.INT:=STRSTART[K];PUT(BASEFILE);
END;K:=0;WHILE K+4<POOLPTR DO BEGIN W.B0:=STRPOOL[K];W.B1:=STRPOOL[K+1];
W.B2:=STRPOOL[K+2];W.B3:=STRPOOL[K+3];BEGIN BASEFILE↑.QQQQ:=W;
PUT(BASEFILE);END;K:=K+4;END;K:=POOLPTR-4;W.B0:=STRPOOL[K];
W.B1:=STRPOOL[K+1];W.B2:=STRPOOL[K+2];W.B3:=STRPOOL[K+3];
BEGIN BASEFILE↑.QQQQ:=W;PUT(BASEFILE);END;PRINTLN;PRINTINT(STRPTR);
PRINT(639);PRINTINT(POOLPTR){:797};{799:}SORTAVAIL;VARUSED:=0;
BEGIN BASEFILE↑.INT:=ROVER;PUT(BASEFILE);END;P:=0;Q:=ROVER;X:=0;
REPEAT FOR K:=P TO Q+1 DO BEGIN BASEFILE↑:=MEM[K];PUT(BASEFILE);END;
X:=X+Q+2-P;VARUSED:=VARUSED+Q-P;P:=Q+MEM[Q].HH.LH;Q:=MEM[Q+1].HH.RH;
UNTIL Q=ROVER;VARUSED:=VARUSED+13000-P;DYNUSED:=MEMEND-12999;
BEGIN BASEFILE↑.INT:=MEMEND;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=AVAIL;PUT(BASEFILE);END;
FOR K:=P TO MEMEND DO BEGIN BASEFILE↑:=MEM[K];PUT(BASEFILE);END;
X:=X+MEMEND+1-P;P:=AVAIL;WHILE P<>0 DO BEGIN DYNUSED:=DYNUSED-1;
P:=MEM[P].HH.RH;END;BEGIN BASEFILE↑.INT:=VARUSED;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=DYNUSED;PUT(BASEFILE);END;PRINTLN;PRINTINT(X);
PRINT(640);PRINTINT(VARUSED);PRINTCHAR(38);PRINTINT(DYNUSED){:799};
{801:}FIXTHIS{:801};{803:}BEGIN BASEFILE↑.INT:=HASHUSED;PUT(BASEFILE);
END;CSCOUNT:=2090-HASHUSED;
FOR P:=HASHBASE TO HASHUSED DO IF HASH[P].RH<>0 THEN BEGIN BEGIN
BASEFILE↑.INT:=P;PUT(BASEFILE);END;BEGIN BASEFILE↑.HH:=HASH[P];
PUT(BASEFILE);END;CSCOUNT:=CSCOUNT+1;END;
FOR P:=HASHUSED+1 TO UNDEFINEDCON-1 DO BEGIN BASEFILE↑.HH:=HASH[P];
PUT(BASEFILE);END;BEGIN BASEFILE↑.INT:=CSCOUNT;PUT(BASEFILE);END;
PRINTLN;PRINTINT(CSCOUNT);PRINT(641){:803};{805:}
BEGIN BASEFILE↑.INT:=INTERACTION;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=BASEIDENT;PUT(BASEFILE);END;
BEGIN BASEFILE↑.INT:=69069;PUT(BASEFILE);END;9:=0{:805};{808:}
WCLOSE(BASEFILE){:808};END;{:790}PROCEDURE|DOSTATEMENT|;LABEL 60;
BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);PRINT(615);END;
ERRORCOUNT:=0;END;{:778}{780:}PROCEDURE GETSYMBOL;LABEL 20;
BEGIN 20:GETNEXT;
IF(CURSYM=0)OR(CURSYM>2091)THEN BEGIN BEGIN IF INTERACTION=3 THEN;
PRINTNL(133);PRINT(624);END;BEGIN HELPPTR:=3;HELPLINE[2]:=625;
HELPLINE[1]:=626;HELPLINE[0]:=627;END;IF CURSYM=0 THEN BACKINPUT;
CURSYM:=2091;INSERROR;GOTO 20;END;END;{:780}{781:}
FUNCTION SCANDECLARED:HALFWORD;LABEL 30;VAR X:HALFWORD;H,T:HALFWORD;
L:HALFWORD;BEGIN GETSYMBOL;X:=CURSYM;
IF EQTB[X].LH<>CURINPUT.NAMEFIELD THEN EQTB[X].LH:=CURINPUT.NAMEFIELD;
IF EQTB[X].RH=0 THEN NEWROOT(X);H:=GETAVAIL;MEM[H].HH.LH:=X;T:=H;
WHILE TRUE DO BEGIN GETNEXT;IF CURSYM=0 THEN GOTO 30;
IF EQTB[CURSYM].LH<>CURINPUT.NAMEFIELD THEN IF EQTB[CURSYM].LH=27 THEN{
782:}BEGIN L:=CURSYM;GETNEXT;IF CURCMD<>55 THEN BEGIN BACKINPUT;
CURSYM:=L;CURCMD:=27;GOTO 30;END ELSE CURSYM:=0;END{:782}ELSE GOTO 30;
MEM[T].HH.RH:=GETAVAIL;T:=MEM[T].HH.RH;MEM[T].HH.LH:=CURSYM;END;
30:SCANDECLARED:=H;END;{:781}{785:}PROCEDURE DOTYPEDECLAR;
VAR T:SMALLNUMBER;P:HALFWORD;BEGIN T:=CURMOD;REPEAT P:=SCANDECLARED;
FLUSHVARIABL(EQTB[MEM[P].HH.LH].RH,MEM[P].HH.RH,FALSE);
Q:=FINDVARIABLE(P);MEM[Q].HH.B0:=T;MEM[Q+1].INT:=0;FLUSHLIST(P);
IF CURCMD<66 THEN{786:}BEGIN BEGIN IF INTERACTION=3 THEN;PRINTNL(133);
PRINT(629);END;BEGIN HELPPTR:=5;HELPLINE[4]:=630;HELPLINE[3]:=631;
HELPLINE[2]:=632;HELPLINE[1]:=633;HELPLINE[0]:=634;END;
IF CURCMD=11 THEN HELPLINE[2]:=635;ERROR;REPEAT GETNEXT;
UNTIL CURCMD>=66;END{:786};UNTIL CURCMD>66;END;{:785}{791:}{614:}
FUNCTION OPENBASEFILE:BOOLEAN;LABEL 40,10;VAR J:0..BUFSIZE;
BEGIN IF BUFFER[CURINPUT.LOCFIELD]=38 THEN BEGIN CURINPUT.LOCFIELD:=
CURINPUT.LOCFIELD+1;J:=CURINPUT.LOCFIELD;BUFFER[LAST]:=32;
WHILE BUFFER[J]<>32 DO J:=J+1;PACKBUFFERED(0,CURINPUT.LOCFIELD,J-1);
IF WOPENIN(BASEFILE)THEN BEGIN CURINPUT.LOCFIELD:=J;GOTO 40;END;
PACKBUFFERED(11,CURINPUT.LOCFIELD,J-1);
IF WOPENIN(BASEFILE)THEN BEGIN CURINPUT.LOCFIELD:=J;GOTO 40;END;;
WRITELN(TERMOUT,'Sorry, I can''t find that base;',' will try PLAIN.');
END;PACKBUFFERED(16,1,0);IF NOT WOPENIN(BASEFILE)THEN BEGIN;
WRITELN(TERMOUT,'I can''t find the PLAIN base file!');
OPENBASEFILE:=FALSE;GOTO 10;END;40:OPENBASEFILE:=TRUE;10:END;{:614}
FUNCTION LOADBASEFILE:BOOLEAN;LABEL 6666,10;VAR J,K:INTEGER;
P,Q:HALFWORD;X:INTEGER;W:FOURQUARTERS;BEGIN{796:}X:=BASEFILE↑.INT;
IF X<>207595411 THEN GOTO 6666;BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF X<>13000 THEN GOTO 6666;BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF X<>2100 THEN GOTO 6666;BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF X<>1777 THEN GOTO 6666{:796};{798:}BEGIN BEGIN GET(BASEFILE);
X:=BASEFILE↑.INT;END;IF X<0 THEN GOTO 6666;IF X>POOLSIZE THEN BEGIN;
WRITELN(TERMOUT,'---! Must increase the ','string pool size');GOTO 6666;
END ELSE POOLPTR:=X;END;BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF X<0 THEN GOTO 6666;IF X>MAXSTRINGS THEN BEGIN;
WRITELN(TERMOUT,'---! Must increase the ','max strings');GOTO 6666;
END ELSE STRPTR:=X;END;FOR K:=0 TO STRPTR DO BEGIN BEGIN GET(BASEFILE);
X:=BASEFILE↑.INT;END;
IF(X<0)OR(X>POOLPTR)THEN GOTO 6666 ELSE STRSTART[K]:=X;END;K:=0;
WHILE K+4<POOLPTR DO BEGIN BEGIN GET(BASEFILE);W:=BASEFILE↑.QQQQ;END;
STRPOOL[K]:=W.B0;STRPOOL[K+1]:=W.B1;STRPOOL[K+2]:=W.B2;
STRPOOL[K+3]:=W.B3;K:=K+4;END;K:=POOLPTR-4;BEGIN GET(BASEFILE);
W:=BASEFILE↑.QQQQ;END;STRPOOL[K]:=W.B0;STRPOOL[K+1]:=W.B1;
STRPOOL[K+2]:=W.B2;STRPOOL[K+3]:=W.B3{:798};{800:}
BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<0)OR(X>13000)THEN GOTO 6666 ELSE ROVER:=X;END;P:=0;Q:=ROVER;X:=0;
REPEAT FOR K:=P TO Q+1 DO BEGIN GET(BASEFILE);MEM[K]:=BASEFILE↑;END;
P:=Q+MEM[Q].HH.LH;
IF(P>13000)OR((Q>=MEM[Q+1].HH.RH)AND(MEM[Q+1].HH.RH<>ROVER))THEN GOTO
6666;Q:=MEM[Q+1].HH.RH;UNTIL Q=ROVER;BEGIN BEGIN GET(BASEFILE);
X:=BASEFILE↑.INT;END;IF X<13000 THEN GOTO 6666;IF X>MEMMAX THEN BEGIN;
WRITELN(TERMOUT,'---! Must increase the ','mem max');GOTO 6666;
END ELSE MEMEND:=X;END;BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<0)OR(X>MEMEND)THEN GOTO 6666 ELSE AVAIL:=X;END;
FOR K:=P TO MEMEND DO BEGIN GET(BASEFILE);MEM[K]:=BASEFILE↑;END;
BEGIN GET(BASEFILE);VARUSED:=BASEFILE↑.INT;END;BEGIN GET(BASEFILE);
DYNUSED:=BASEFILE↑.INT;END;MAXVARUSED:=VARUSED{:800};{802:}FIXTHIS{:802}
;{804:}BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<HASHBASE)OR(X>2091)THEN GOTO 6666 ELSE HASHUSED:=X;END;
P:=HASHBASE-1;REPEAT BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<P+1)OR(X>HASHUSED)THEN GOTO 6666 ELSE P:=X;END;BEGIN GET(BASEFILE);
HASH[P]:=BASEFILE↑.HH;END;UNTIL P=HASHUSED;
FOR P:=HASHUSED+1 TO UNDEFINEDCON-1 DO BEGIN GET(BASEFILE);
HASH[P]:=BASEFILE↑.HH;END;BEGIN GET(BASEFILE);CSCOUNT:=BASEFILE↑.INT;
END{:804};{806:}BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<0)OR(X>3)THEN GOTO 6666 ELSE INTERACTION:=X;END;
BEGIN BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<0)OR(X>STRPTR)THEN GOTO 6666 ELSE BASEIDENT:=X;END;
BEGIN GET(BASEFILE);X:=BASEFILE↑.INT;END;
IF(X<>69069)OR EOF(BASEFILE)THEN GOTO 6666{:806};LOADBASEFILE:=TRUE;
GOTO 10;6666:;WRITELN(TERMOUT,'(Fatal base file error; I''m stymied)');
LOADBASEFILE:=FALSE;10:END;{:791}{809:}{812:}PROCEDURE CLOSEFILESAN;
VAR K:INTEGER;
BEGIN{IF 9>0 THEN[813:]IF JOBNAME>0 THEN BEGIN WRITELN(LOGFILE,' ');
WRITELN(LOGFILE,'Here is how much of METAFONT''s memory',' you used:');
WRITE(LOGFILE,' ',STRPTR-INITSTRPTR:1,' string');
IF STRPTR<>INITSTRPTR+1 THEN WRITE(LOGFILE,'s');
WRITELN(LOGFILE,' out of ',MAXSTRINGS-INITSTRPTR:1);
WRITELN(LOGFILE,' ',POOLPTR-INITPOOLPTR:1,' string characters out of ',
POOLSIZE-INITPOOLPTR:1);
WRITELN(LOGFILE,' ',MAXVARUSED:1,'&',MEMEND-12999:1,
' words of memory out of ',13000:1,'&',MEMMAX-12999:1);
WRITELN(LOGFILE,' ',STCOUNT:1,' multiletter control sequences out of ',
2100:1);
WRITELN(LOGFILE,' ',MAXINSTACK:1,'i,',MAXNESTSTACK:1,'n,',MAXPARAMSTAC:1
,'p,',MAXBUFSTACK+1:1,'b stack positions out of ',STACKSIZE:1,'i,',
NESTSIZE:1,'n,',PARAMSIZE:1,'p,',BUFSIZE:1,'b,');END[:813];};{665:}
IF GFPREVPTR>0 THEN BEGIN BEGIN GFBUF[GFPTR]:=248;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;GFFOUR(GFPREVPTR);
GFPREVPTR:=GFOFFSET+GFPTR-5;GFFOUR(INTERNAL[21]*16);GFFOUR(CHECKSUM);
GFFOUR(INTERNAL[22]);GFFOUR(GFMINX);GFFOUR(GFMAXX-1);GFFOUR(GFMINY);
GFFOUR(GFMAXY);
FOR K:=0 TO 255 DO IF CHARPTR[K]>=0 THEN BEGIN BEGIN GFBUF[GFPTR]:=243;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;BEGIN GFBUF[GFPTR]:=K;
GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;GFFOUR(TFMWIDTH[K]);
GFFOUR(CHARPTR[K]);END;BEGIN GFBUF[GFPTR]:=249;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;GFFOUR(GFPREVPTR);
BEGIN GFBUF[GFPTR]:=129;GFPTR:=GFPTR+1;IF GFPTR=GFLIMIT THEN GFSWAP;END;
K:=4+((GFBUFSIZE-GFPTR)MOD 4);
WHILE K>0 DO BEGIN BEGIN GFBUF[GFPTR]:=223;GFPTR:=GFPTR+1;
IF GFPTR=GFLIMIT THEN GFSWAP;END;K:=K-1;END;{652:}
IF GFLIMIT=HALFBUF THEN WRITEGF(HALFBUF,GFBUFSIZE-1);
IF GFPTR>0 THEN WRITEGF(0,GFPTR-1){:652};PRINTNL(526);
PRINT(OUTPUTFILENA);PRINT(527);PRINTINT(TOTALCHARS);PRINT(528);
IF TOTALCHARS<>0 THEN PRINTCHAR(115);PRINT(529);
PRINTINT(GFOFFSET+GFPTR);PRINT(530);BCLOSE(GFFILE);END{:665};
IF JOBNAME>0 THEN BEGIN WRITELN(LOGFILE);ACLOSE(LOGFILE);
SELECTOR:=SELECTOR-2;IF SELECTOR=1 THEN BEGIN PRINTNL(646);
PRINT(LOGNAME);PRINTCHAR(46);END;END;END;{:812}{814:}
PROCEDURE FINALCLEANUP;LABEL 10;VAR C:SMALLNUMBER;BEGIN C:=CURCHR;
IF JOBNAME=0 THEN OPENLOGFILE;WHILE CONDPTR<>0 DO BEGIN PRINTNL(40);
PRINTESC(647);PRINT(648);PRINTCMDMOD(2,CURIF);
IF IFLINE<>0 THEN BEGIN PRINT(649);PRINTINT(IFLINE);END;PRINT(650);
IFLINE:=MEM[CONDPTR+1].INT;CURIF:=SUBTYPE(CONDPTR);
CONDPTR:=MEM[CONDPTR].HH.RH;END;
IF HISTORY<>0 THEN IF((HISTORY=1)OR(INTERACTION<3))THEN IF SELECTOR=3
THEN BEGIN SELECTOR:=1;PRINTNL(651);SELECTOR:=3;END;
IF C=1 THEN BEGIN STOREBASEFIL;GOTO 10;PRINTNL(652);GOTO 10;END;10:END;
{:814}{815:}PROCEDURE INITPRIM;BEGIN{184:}PRIMITIVE(274,16,1);
PRIMITIVE(275,16,2);PRIMITIVE(276,16,3);PRIMITIVE(277,16,4);
PRIMITIVE(278,16,5);PRIMITIVE(279,16,6);PRIMITIVE(280,16,7);
PRIMITIVE(281,16,8);PRIMITIVE(282,16,9);PRIMITIVE(283,16,10);
PRIMITIVE(284,16,11);PRIMITIVE(285,16,12);PRIMITIVE(286,16,13);
PRIMITIVE(287,16,14);PRIMITIVE(288,16,15);PRIMITIVE(289,16,16);
PRIMITIVE(290,16,17);PRIMITIVE(291,16,18);PRIMITIVE(292,16,19);
PRIMITIVE(293,16,20);PRIMITIVE(294,16,21);PRIMITIVE(295,16,22);
PRIMITIVE(296,16,23);PRIMITIVE(297,16,24);PRIMITIVE(298,16,25);
PRIMITIVE(299,16,26);{:184}{199:}PRIMITIVE(38,22,0);PRIMITIVE(303,23,0);
PRIMITIVE(61,25,0);PRIMITIVE(91,27,0);PRIMITIVE(47,29,0);
PRIMITIVE(93,55,0);PRIMITIVE(125,56,0);PRIMITIVE(123,57,0);
PRIMITIVE(58,64,0);PRIMITIVE(304,65,0);PRIMITIVE(44,66,0);
PRIMITIVE(59,67,0);PRIMITIVE(305,37,0);PRIMITIVE(250,26,0);
PRIMITIVE(306,59,0);PRIMITIVE(307,62,0);PRIMITIVE(308,9,0);
PRIMITIVE(309,50,0);PRIMITIVE(310,53,0);PRIMITIVE(311,52,0);
PRIMITIVE(312,46,0);PRIMITIVE(313,68,0);PRIMITIVE(314,45,0);
PRIMITIVE(315,60,0);PRIMITIVE(316,2,0);PRIMITIVE(317,32,0);
PRIMITIVE(318,33,0);PRIMITIVE(319,58,0);PRIMITIVE(320,47,0);
PRIMITIVE(321,43,0);PRIMITIVE(322,6,0);PRIMITIVE(323,42,0);
PRIMITIVE(324,31,0);PRIMITIVE(325,36,0);PRIMITIVE(326,51,0);
PRIMITIVE(327,61,0);PRIMITIVE(328,63,0);{:199}{213:}PRIMITIVE(338,49,1);
PRIMITIVE(339,49,2);PRIMITIVE(340,49,3);{:213}{548:}PRIMITIVE(452,34,1);
PRIMITIVE(453,34,2);PRIMITIVE(454,34,3);PRIMITIVE(455,34,4);
PRIMITIVE(456,34,5);PRIMITIVE(457,34,0)PRIMITIVE(458,4,1);
PRIMITIVE(459,4,0);PRIMITIVE(460,35,1);PRIMITIVE(461,35,2);
PRIMITIVE(462,35,0);{:548}{553:}PRIMITIVE(464,MACROSPECIAL,0);
PRIMITIVE(465,MACROSPECIAL,1);PRIMITIVE(64,MACROSPECIAL,2);
PRIMITIVE(466,MACROSPECIAL,3);{:553}{561:}PRIMITIVE(473,PARAMTYPE,2101);
PRIMITIVE(474,PARAMTYPE,2101+PARAMSIZE);
PRIMITIVE(475,PARAMTYPE,2101+PARAMSIZE+PARAMSIZE);
PRIMITIVE(338,PARAMTYPE,0);{:561}{571:}PRIMITIVE(480,1,0);
PRIMITIVE(481,1,1);{:571}{588:}PRIMITIVE(497,3,2);PRIMITIVE(498,3,3);
PRIMITIVE(499,3,4);{:588}{671:}PRIMITIVE(531,10,1);PRIMITIVE(532,10,0);
{:671}{739:}PRIMITIVE(326,51,1);PRIMITIVE(589,51,0);{:739}{751:}
PRIMITIVE(220,13,30);PRIMITIVE(221,13,31);PRIMITIVE(222,13,32);
PRIMITIVE(223,13,33);PRIMITIVE(224,14,34);PRIMITIVE(225,14,35);
PRIMITIVE(226,14,36);PRIMITIVE(227,14,37);PRIMITIVE(228,14,38);
PRIMITIVE(229,14,39);PRIMITIVE(230,14,40);PRIMITIVE(231,14,41);
PRIMITIVE(232,14,42);PRIMITIVE(233,14,43);PRIMITIVE(234,14,44);
PRIMITIVE(235,14,45);PRIMITIVE(236,14,46);PRIMITIVE(237,14,47);
PRIMITIVE(238,14,48);PRIMITIVE(239,14,49);PRIMITIVE(240,14,50);
PRIMITIVE(241,14,51);PRIMITIVE(242,14,52);PRIMITIVE(243,14,53);
PRIMITIVE(244,14,54);PRIMITIVE(245,14,55);PRIMITIVE(248,14,58);
PRIMITIVE(246,14,56);PRIMITIVE(247,14,57);PRIMITIVE(43,19,59);
PRIMITIVE(45,19,60);PRIMITIVE(42,30,61);PRIMITIVE(47,30,62);
PRIMITIVE(249,21,63);PRIMITIVE(250,26,64);PRIMITIVE(251,21,65);
PRIMITIVE(60,24,66);PRIMITIVE(252,24,67);PRIMITIVE(62,24,68);
PRIMITIVE(253,24,69);PRIMITIVE(61,25,70);PRIMITIVE(254,24,71);
PRIMITIVE(255,15,72);PRIMITIVE(256,15,73);PRIMITIVE(257,15,74);
PRIMITIVE(258,15,75);PRIMITIVE(259,15,76);PRIMITIVE(260,15,77);
PRIMITIVE(261,15,78);PRIMITIVE(262,15,79);PRIMITIVE(263,15,80);
PRIMITIVE(38,22,81);PRIMITIVE(264,21,82);PRIMITIVE(265,30,83);
PRIMITIVE(266,30,84);PRIMITIVE(267,30,85);PRIMITIVE(268,30,86);
PRIMITIVE(269,30,87);PRIMITIVE(270,30,88);PRIMITIVE(271,30,89);
PRIMITIVE(272,30,90);PRIMITIVE(273,21,91);{:751}{783:}
PRIMITIVE(213,7,18);PRIMITIVE(199,7,4);PRIMITIVE(197,7,2);
PRIMITIVE(206,7,11);PRIMITIVE(201,7,6);PRIMITIVE(204,7,9);
PRIMITIVE(208,7,13);PRIMITIVE(209,7,14);{:783};END;{:815}{817:}
{PROCEDURE DEBUGHELP;LABEL 888,10;VAR K,L,M,N:INTEGER;
BEGIN WHILE TRUE DO BEGIN;PRINTNL(653);BREAK(TERMOUT);READ(TERMIN,M);
IF M<0 THEN GOTO 10 ELSE IF M=0 THEN BEGIN GOTO 888;
888:M:=0;
['BREAKPOINT']
END ELSE BEGIN READ(TERMIN,N);CASE M OF[818:]1:PRINTWORD(MEM[N]);
2:PRINTINT(MEM[N].HH.LH);3:PRINTINT(MEM[N].HH.RH);4:PRINTWORD(EQTB[N]);
6:PRINTINT(INTERNAL[N]);9:SHOWTOKENLIS(N,0,1000);10:PRINT(N);
11:CHECKMEM(N>0);12:SEARCHMEM(N);13:BEGIN READ(TERMIN,L);
PRINTCMDMOD(N,L);END;14:FOR K:=0 TO N DO PRINT(BUFFER[K]);
16:PANICKING:=NOT PANICKING;[:818]OTHERS:PRINT(63)END;END;END;10:END;}
{:817}{:809}{811:}BEGIN HISTORY:=3;REWRITE(TERMOUT,'TTY:','/O');
IF READYALREADY=314159 THEN GOTO 1;INITIALIZE;{14:}BAD:=0;
IF(HALFERRORLIN<30)OR(HALFERRORLIN>ERRORLINE-15)THEN BAD:=1;
IF MAXPRINTLINE<60 THEN BAD:=2;IF GFBUFSIZE MOD 8<>0 THEN BAD:=3;
IF(13000<100)OR(13100>MEMMAX)THEN BAD:=4;IF 1777>2100 THEN BAD:=5;{:14}
{147:}IF(0>0)OR(255<127)THEN BAD:=11;IF(0>0)OR(65535<32767)THEN BAD:=12;
IF(0<0)OR(255>65535)THEN BAD:=13;IF(0<0)OR(MEMMAX>=65535)THEN BAD:=14;
IF(SAVESIZE>65535)OR(MAXSTRINGS>65535)THEN BAD:=15;
IF BUFSIZE>65535 THEN BAD:=16;{:147}{202:}
IF 2101+PARAMSIZE+PARAMSIZE+PARAMSIZE>65535 THEN BAD:=21;{:202}{315:}
IF 14*11>BISTACKSIZE THEN BAD:=21;{:315}{612:}
IF 21>FILENAMESIZE THEN BAD:=31;{:612}IF BAD>0 THEN BEGIN;
WRITE(TERMOUT,'Ouch---my internal constants have been',
' clobbered!---case ',BAD:1);GOTO 9999;END;
IF NOT GETSTRINGSST THEN GOTO 9999;INITPRIM;READYALREADY:=314159;1:{55:}
SELECTOR:=1;TALLY:=0;TERMOFFSET:=0;FILEOFFSET:=0;{:55}{60:}
WRITE(TERMOUT,'This is METAFONT, Version -100.0');
IF BASEIDENT=0 THEN WRITELN(TERMOUT,' (no base preloaded)')ELSE BEGIN
PRINT(BASEIDENT);PRINTLN;END;{:60}{618:}JOBNAME:=0;{:618}{623:}
OUTPUTFILENA:=0;{:623};{816:}BEGIN{526:}BEGIN INPUTPTR:=0;MAXINSTACK:=0;
INOPEN:=0;MAXBUFSTACK:=0;PARAMPTR:=0;MAXPARAMSTAC:=0;
SCANNERSTATU:=NORMAL;FIRST:=1;CURINPUT.STARTFIELD:=1;
CURINPUT.INDEXFIELD:=0;LINE:=0;CURINPUT.NAMEFIELD:=0;FORCEEOF:=FALSE;
IF NOT INITTERMINAL THEN GOTO 9999;CURINPUT.LIMITFIELD:=LAST;
FIRST:=LAST+1;END{:526};
IF(BASEIDENT=0)OR(BUFFER[CURINPUT.LOCFIELD]=38)THEN BEGIN IF BASEIDENT<>
0 THEN INITIALIZE;IF NOT OPENBASEFILE THEN GOTO 9999;
IF NOT LOADBASEFILE THEN BEGIN WCLOSE(BASEFILE);GOTO 9999;END;
WCLOSE(BASEFILE);
WHILE(CURINPUT.LOCFIELD<CURINPUT.LIMITFIELD)AND(BUFFER[CURINPUT.LOCFIELD
]=32)DO CURINPUT.LOCFIELD:=CURINPUT.LOCFIELD+1;END;
BUFFER[CURINPUT.LIMITFIELD]:=37;FIXDATEANDTI;{69:}
IF INTERACTION=0 THEN SELECTOR:=0 ELSE SELECTOR:=1{:69};
IF BUFFER[LOG]<>92 THEN STARTINPUT;END{:816};INITSTRPTR:=STRPTR;
INITPOOLPTR:=POOLPTR;HISTORY:=0;MAINCONTROL;FINALCLEANUP;
9998:CLOSEFILESAN;9999:READYALREADY:=0;END.{:811}